The backbone your platform runs on.
Infrastructure as a platform: a deterministic Node.js runtime, thread-isolated workers, secrets resolved at runtime, and real React apps built and served in cloud — one operational signature across your whole stack.
const { Loom } = require('@link-loom/sdk');
const loom = new Loom({
root: __dirname,
name: 'billing-svc',
});
const main = async () => {
// DI → infra → adapters → traffic
const dependencies = await loom.ignite();
dependencies.console.success('Runtime active');
};
main();class InvoiceWorker extends BaseWorker {
// Runs in its own V8 isolate. Crash-safe.
async activateBackground(ctx) {
const { payload, logger } = ctx;
logger.info('Processing invoice…');
const result = await this.settle(payload);
return { ok: true, data: result, port: 'done' };
}
}// .env stays empty — secrets resolve at runtime
const loom = new Loom({ root: __dirname });
// ignite() pulls the environment from Cloud Vault
const deps = await loom.ignite();
const stripeKey = deps.config.providers.stripe.key;
// held in memory, never written to diskclass DailyReportFunction {
constructor(deps) {
this._email = deps.adapters.email;
}
// Runs every day at 9:00 — no crontab
async run() {
await this._email.sendAdminReport();
}
} Every layer works alone. Together, they are a platform.
Five layers, one operational signature. Start with the open-source runtime; grow into workers, vault, services and cloud-built apps at your own pace.
- 01 Runtime SDK Deterministic boot, explicit dependency injection, lifecycle as a state machine. loom.ignite()
- 02 Workers Thread-isolated execution units with a full FSM lifecycle and total memory reclaim. [Loom]::[Workers]
- 03 Cloud Vault Environments and secrets resolved at runtime. Nothing sensitive in your repo. config ← vault
- 04 Cloud Services The backbone services every platform needs — identity, notifications, storage, observability. identity · storage · events
- 05 App Engine Real React apps — stored, built, versioned and served from the cloud. app.build()
SDK → Workers → Vault → Services → Apps. One signature, end to end.
Six modules. One operational signature.
Each module is production infrastructure on its own. Composed, they run your whole platform — from process boot to the app your users open.
The runtime is open. The platform runs on it.
The Link Loom SDK is open source and runs the same code on your laptop, your datacenter and our cloud. No black box at the foundation of your stack.
- require('@link-loom/sdk') One dependency Runtime, DI, adapters, workers and streams ship in a single package.
- BaseWorker · adapters Primitives, not magic Everything the platform does is built on documented base classes your own code can extend.
- ignite() everywhere Cloud-optional by design Everything works offline. Cloud Vault, App Engine and managed services attach when you want them.
Ignite. Compose. Operate.
- loom.ignite()
Ignite
One call boots the runtime: dependencies resolve, infrastructure connects, adapters load — in a guaranteed order, every time.
- spawn → activate → stop
Compose
Wire services, spawn workers, attach vault and storage. Every capability arrives through the same dependency graph.
- build · version · serve
Operate
Ship apps from App Studio, version them in App Engine, watch every workload with the same observability.
One runtime. Every workload.
- worker lifecycle states — spawn to guillotine
- 7
- adapters & infrastructure modules in the SDK
- 10+
- worker memory reclaimed on termination
- 100%
- secrets written to disk — Vault resolves at runtime
- 0
- 01 Install npm i @link-loom/sdk. Ignite your first service today.
- 02 Compose Add workers, vault and services as your platform grows.
- 03 Ship Build and version apps in cloud. Serve them anywhere.