@nimbus-sh/loom 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ashish Kumar Singh and Nimbus contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,163 @@
+# @nimbus-sh/loom
+
+> Part of [Nimbus](https://github.com/AshishKumar4/Nimbus), my hobby/research
+> cloud OS. This README is edited and maintained with Claude (AI) and
+> presented as-is.
+
+An actor framework for Cloudflare Durable Objects. On top it is
+[partyserver](https://github.com/cloudflare/partykit/tree/main/packages/partyserver)'s
+surface, unchanged: `Actor extends Server`, so routing, connections, tags,
+broadcast, and hibernation work exactly as partyserver documents them.
+Underneath it is [`@nimbus-sh/fabric`](https://www.npmjs.com/package/@nimbus-sh/fabric),
+the Durable Object machinery Nimbus runs in production, pre-wired so an
+embedder writes one class instead of the wiring.
+
+Cloudflare's own Agents SDK takes the same shape (`Agent extends Server`).
+Where the two overlap, loom keeps the SDK's API and wire protocol so its
+clients are not surprised, and swaps the machinery for fabric's where
+fabric's is measurably stronger. Every such claim below was verified against
+the shipped `agents` 0.20.1 dist, not its docs. partyserver is pinned to an
+exact version (0.5.10); loom extends its prototype surface, and a floating
+prototype dependency is a drift channel.
+
+## One class
+
+```ts
+import { Actor, callable, routeActorRequest } from '@nimbus-sh/loom';
+
+interface CounterState {
+  count: number;
+}
+
+export class Counter extends Actor<Env, CounterState> {
+  static options = { hibernate: true };
+  initialState: CounterState = { count: 0 };
+
+  @callable()
+  increment(by: number): number {
+    this.setState({ count: this.state.count + by });
+    return this.state.count;
+  }
+
+  async remind(payload: { what: string }): Promise<void> {
+    this.broadcast(`reminder: ${payload.what}`);
+  }
+
+  async onRequest(request: Request): Promise<Response> {
+    await this.schedule(60, 'remind', { what: 'tea' });
+    return Response.json(this.state);
+  }
+}
+
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    return (await routeActorRequest(request, env))
+      ?? new Response('not found', { status: 404 });
+  },
+} satisfies ExportedHandler<Env>;
+```
+
+`routeActorRequest` and `getActorByName` are partyserver's router
+re-exported, URL convention included (`/parties/<binding>/<name>`); a
+parallel implementation would drift. Actor classes must be SQLite-backed
+Durable Objects (`new_sqlite_classes`, the default for new classes); state
+and schedules live in the actor's own SQLite.
+
+## The floor you inherit
+
+**Nothing async on the init gate.** The constructor is synchronous.
+partyserver's gate runs exactly your `onStart`, and a gate callback still
+pending at ~30 s is cancelled and resets the object, so `onStart` must stay
+short. Work that belongs to a fresh incarnation goes through
+`this.deferToColdStart(task)` and runs on the first turn the actor owns.
+Generation adoption (`this.generation`, fabric's incarnation counter) and
+fenced-work recovery ride the same turn.
+
+**One alarm, many reasons.** A Durable Object has one alarm, and a second
+`setAlarm()` silently overwrites the first. `alarm()` therefore dispatches
+fabric's reason map: register a reason with `registerTimerReason` in the
+constructor, arm it with `this.timers.schedule(reason, whenMs)`, re-arm by
+returning `{ rearmAt }` from the handler. The schedule API and every outbox
+are reasons in the same map, so nothing clobbers anything.
+
+**Scheduling.** `schedule(when, callback, payload?)` takes a delay in
+seconds, a `Date`, or a cron expression; `scheduleEvery(intervalSeconds,
+...)` is a fixed interval. `getScheduleById`, `listSchedules`,
+`cancelSchedule` read and cancel. The callback receives
+`(payload, invocation)` where the invocation carries the schedule, the
+attempt number, and the platform's `alarmInfo` (`isRetry`, `retryCount`),
+which the Agents SDK drops. Retries are durable: a failed attempt writes its
+backed-off deadline into the row, so the budget survives an instance reset
+instead of sleeping inside the alarm turn. Times are epoch milliseconds.
+
+**State sync.** Declare `initialState`, read `this.state`, write
+`setState(next)`. State persists to SQLite and broadcasts to every
+connection as a `cf_agent_state` frame (the Agents wire protocol, so its
+clients work as-is). A client can send the same frame back;
+`validateStateChange(next, source)` vetoes synchronously before anything
+persists, and `onStateChanged(state, source)` runs after. A refused client
+update earns a `cf_agent_state_error` frame.
+
+**Callable RPC.** Mark a method `@callable()` and any connection can invoke
+it by name; everything unmarked is refused. `@callable({ streaming: true })`
+prepends a `StreamingResponse` to the arguments for chunked replies. The
+caller side is `actorClient(socket)` from `@nimbus-sh/loom/client.js` —
+dependency-free and workerd-free, with `call(method, args)` and a typed
+`stub<T>()` proxy.
+
+**Per-connection state.** `this.connections(schema)` is fabric's typed,
+validated, hibernation-durable attachment state over partyserver's
+`Connection` surface: `read` validates instead of casting (an attachment
+written by a previous deploy is untrusted input), `write` validates on the
+way in, tags address connections. partyserver owns the accept; tag
+connections in `getConnectionTags`. Hibernating actors only — the state
+rides the hibernatable socket attachment, and a non-hibernating actor is
+refused with an error rather than corrupted later.
+
+**Durable messaging.** `this.outbox(name, policy)` is a write-ahead retry
+outbox (dispositions, per-key ordering, dead letters), its drain registered
+as a timer reason the moment you create it. Create outboxes in the
+constructor: a queued row survives an instance reset, but the alarm
+dispatcher drops a fired reason no handler answers, so an outbox first
+created inside a request path is unregistered until that path runs again.
+`this.journal(name)` is an append-only event log with dedupe and
+self-expiring delivery leases.
+
+**Processes and facets.** `this.facets` leases DO facets so reclaiming
+storage is the default and leaking it takes an explicit `detach()`.
+`this.processes` is fabric's process fabric over a substrate you declare by
+overriding `processHost()`. `this.derived` / `this.derivedAsync` are the
+watermark memos.
+
+**Hibernation, configured.** `static options = { hibernate: true }` opts
+into partyserver's hibernation and also applies fabric's config: `ping`/
+`pong` auto-response (a matched frame no longer wakes the actor) and the 5 s
+hibernatable-event timeout. `this.hibernation` reports what the runtime
+supported. State your fabric composition once, on the class:
+`static options = { fabric: { supervisorEntrypoint: '...' } }`.
+
+Define hooks (`onMessage`, `onConnect`, ...) as methods, not instance
+fields. Loom wraps them at construction to pay the floor work and consume
+protocol frames; an instance field assigns over the wiring.
+
+## What this is not
+
+There is no chat surface, no MCP, no email routing, no React hooks, and no
+Workflows integration. That is the Agents SDK's product surface; loom stops
+at the framework layer. If you need those today, use `agents` — its `Agent`
+and loom's `Actor` are siblings on the same partyserver base, and they do
+not share a Durable Object.
+
+## Importing it
+
+Your Worker must set `compatibility_flags: ["nodejs_compat"]`. Loom dispatches
+timers through fabric, and fabric's dispatcher imports `AsyncLocalStorage`
+from `node:async_hooks`. Without the flag the module fails to load at deploy
+time.
+
+The root export pulls `partyserver`, which imports `cloudflare:workers`, so
+`import ... from '@nimbus-sh/loom'` resolves only inside a Worker. Outside
+workerd (unit tests, browsers) import subpaths: `@nimbus-sh/loom/client.js`
+and `@nimbus-sh/loom/protocol.js` are workerd-free by design, and
+`@nimbus-sh/loom/schedules.js` is structurally typed for plain-process
+tests, the same discipline as fabric.

package/dist/actor.d.ts

@@ -0,0 +1,222 @@
+/**
+ * actor.ts — `Actor`, a partyserver `Server` standing on the fabric floor.
+ *
+ * partyserver contributes the surface: routing, connections, tags,
+ * broadcast, hibernation opt-in, `onStart`/`onConnect`/`onMessage`/
+ * `onRequest`/`onClose`/`onError`. Fabric contributes the machinery a
+ * Durable Object needs under that surface, and this class wires it so an
+ * embedder never does:
+ *
+ *   - ONE ALARM, MANY REASONS. `alarm()` dispatches fabric's reason map;
+ *     the embedder registers reasons ({@link Actor.registerTimerReason})
+ *     and arms them (`this.timers`). The schedule API and every outbox are
+ *     reasons in the same map. The platform's `alarmInfo` rides through to
+ *     every handler.
+ *   - NOTHING ASYNC ON THE INIT GATE. The constructor is synchronous.
+ *     partyserver's own gate runs exactly `onStart` (its `#ensureInitialized`,
+ *     a `blockConcurrencyWhile`); a gate callback still pending at ~30 s is
+ *     cancelled and RESETS the object, so `onStart` must stay short.
+ *     Everything the floor defers — generation adoption, cold-start
+ *     reconciliation, fenced-work recovery — runs on the first turn the
+ *     actor already owns: every entry point passes {@link Actor.#enterTurn}
+ *     after initialization and before embedder code. One platform
+ *     exception: partyserver's fetch asks `getConnectionTags` during the
+ *     accept, before the connect turn's floor entry — keep that hook pure.
+ *   - HIBERNATION CONFIGURED, NOT JUST ENABLED. With
+ *     `static options = { hibernate: true }`, the constructor also applies
+ *     fabric's ws-hibernation config: ping/pong auto-response (a matched
+ *     frame no longer wakes the actor) and the 5 s hibernatable-event
+ *     timeout. The result is on `this.hibernation` for diagnostics.
+ *   - COMPOSITION STATED ONCE. `static options = { fabric: {...} }` feeds
+ *     `composeFabric`, and the constructor captures `ctx.exports` where the
+ *     platform hands it over. Both are first-write-wins.
+ *
+ * Protocol frames (state sync, callable RPC — see protocol.ts) are consumed
+ * before `onMessage`; everything else reaches the embedder untouched. For
+ * that interception to hold, hooks must be prototype METHODS — an instance
+ * field (`onMessage = () => {}`) assigns over the wiring.
+ *
+ * The state and schedule tables live in the actor's own SQLite, so an Actor
+ * class must be SQLite-backed (`new_sqlite_classes` — the default for new
+ * classes).
+ */
+import { Server, type Connection } from 'partyserver';
+import { type TimerAlarmInfo, type TimerHandlerResult, type Timers } from '@nimbus-sh/fabric/timers.js';
+import { type Outbox, type OutboxPolicy } from '@nimbus-sh/fabric/outbox.js';
+import { type Journal } from '@nimbus-sh/fabric/journal.js';
+import { type FacetPool } from '@nimbus-sh/fabric/facet-pool.js';
+import { type Derived, type DerivedAsync, type DerivedAsyncHooks, type DerivedHooks } from '@nimbus-sh/fabric/derived.js';
+import { FencedWork, type FencedWorkHost, type FencedWorkRecord } from '@nimbus-sh/fabric/fenced-work.js';
+import { type FabricComposition } from '@nimbus-sh/fabric/composition.js';
+import { type WsHibernationConfigResult } from '@nimbus-sh/fabric/ws-hibernation-config.js';
+import { ProcessFabric, type ProcessHost } from '@nimbus-sh/fabric/process-fabric.js';
+import type { z } from 'zod/v4';
+import { type Schedule, type ScheduleCriteria, type ScheduleOptions } from './schedules.js';
+/** The timer reason the schedule store dispatches under. */
+export declare const SCHEDULE_TIMER_REASON = "loom:schedule";
+/** Static configuration, inherited through the class chain like partyserver's. */
+export interface ActorOptions {
+    /** partyserver's hibernation opt-in; loom also applies fabric's ws config. */
+    hibernate?: boolean;
+    /**
+     * The embedder's fabric composition, stated once on the class. Fed to
+     * `composeFabric` (first-write-wins) before anything can need it.
+     */
+    fabric?: FabricComposition;
+}
+/**
+ * Typed, validated per-connection state over partyserver's `Connection`
+ * surface — fabric's `connections` machinery with the accept half left to
+ * partyserver, which owns the accept.
+ */
+export interface TypedConnections<T> {
+    /** The open connection holding a tag, or null. */
+    get(tag: string): Connection | null;
+    /** Every open connection (optionally: holding a tag). */
+    list(tag?: string): Connection[];
+    /** A connection's tags — its id first, then `getConnectionTags`' additions. */
+    tags(connection: Connection): string[];
+    /**
+     * The attachment, validated. Null when it does not parse — an attachment
+     * written by a previous deploy is untrusted input.
+     */
+    read(connection: Connection): T | null;
+    /** Replace the attachment, validated on the way in. */
+    write(connection: Connection, attachment: T): void;
+}
+export declare class Actor<Env extends Cloudflare.Env = Cloudflare.Env, State = unknown, Props extends Record<string, unknown> = Record<string, unknown>> extends Server<Env, Props> {
+    #private;
+    static options: ActorOptions;
+    /** fabric `TimerHost`: the chain serializing this instance's timer map. */
+    _timerChain?: Promise<unknown>;
+    /**
+     * Fabric's ws-hibernation configuration result, when
+     * `options.hibernate` asked for it; null otherwise. Reports honestly
+     * which half the runtime supported.
+     */
+    readonly hibernation: WsHibernationConfigResult | null;
+    /**
+     * The state broadcast to (and settable by) connections. Assign it in the
+     * subclass; leave it unassigned for a stateless actor.
+     */
+    initialState: State;
+    constructor(ctx: DurableObjectState, env: Env);
+    /**
+     * The native-RPC entry point (`getActorByName` calls it before any
+     * embedder RPC method) pays the turn entry too, after partyserver has
+     * initialized.
+     */
+    setName(name: string, props?: Props): Promise<void>;
+    /**
+     * partyserver initialization, then the floor, then `onAlarm`, then
+     * fabric's dispatcher runs every due reason with the platform's
+     * `alarmInfo`. Handlers re-arm through their return value; the map's
+     * earliest remaining deadline re-arms the platform alarm.
+     * `__unsafe_ensureInitialized` is partyserver's documented escape hatch
+     * for frameworks; calling it here (instead of `super.alarm()`) is what
+     * lets `onAlarm` run AFTER the floor, like every other embedder hook.
+     */
+    alarm(alarmInfo?: TimerAlarmInfo): Promise<void>;
+    /** partyserver logs "implement onAlarm" per fire; an empty hook is the default here. */
+    onAlarm(): void | Promise<void>;
+    /**
+     * Register the handler for one timer reason. Reasons are the alarm's
+     * multiplexing key: register in the constructor, arm with
+     * `this.timers.schedule(reason, whenMs)`, re-arm by returning
+     * `{ rearmAt }` from the handler. One handler per reason, for the
+     * instance's lifetime.
+     */
+    protected registerTimerReason(reason: string, handler: (now: number, info?: TimerAlarmInfo) => TimerHandlerResult | Promise<TimerHandlerResult>): void;
+    /**
+     * Schedule a method call: `when` is a delay in seconds, an absolute
+     * `Date`, or a cron expression. The callback fires as
+     * `this[callback](payload, invocation)`; the invocation carries the
+     * schedule, the attempt number, and the platform's `alarmInfo`. Retries
+     * are durable rows (see schedules.ts), governed by `options.retry`.
+     */
+    schedule<T = unknown>(when: number | Date | string, callback: keyof this & string, payload?: T, options?: ScheduleOptions): Promise<Schedule<T>>;
+    /** Schedule a method call every `intervalSeconds`, first fire one interval from now. */
+    scheduleEvery<T = unknown>(intervalSeconds: number, callback: keyof this & string, payload?: T, options?: ScheduleOptions): Promise<Schedule<T>>;
+    getScheduleById<T = unknown>(id: string): Promise<Schedule<T> | undefined>;
+    listSchedules<T = unknown>(criteria?: ScheduleCriteria): Promise<Array<Schedule<T>>>;
+    /** True when the id existed and is now cancelled. */
+    cancelSchedule(id: string): Promise<boolean>;
+    /**
+     * A schedule's retry budget is spent (or its callback is not a method).
+     * The default names the failure; override to route it.
+     */
+    onScheduleError(schedule: Schedule, error: unknown): void;
+    /**
+     * The synced state. Loaded from SQLite on first read; `initialState`
+     * before anything was ever set; undefined for a stateless actor.
+     */
+    get state(): State;
+    /** Replace the state: validate, persist, broadcast, notify. */
+    setState(state: State): void;
+    /**
+     * Synchronous veto over every state change, the embedder's own and a
+     * connection's alike. Runs BEFORE anything persists; throw to refuse.
+     * A refused connection update earns the client a
+     * `cf_agent_state_error` frame.
+     */
+    validateStateChange(_next: State, _source: Connection | 'server'): void;
+    /** The state changed and is already persisted and broadcast. */
+    onStateChanged(_state: State, _source: Connection | 'server'): void | Promise<void>;
+    /** This actor's reason map over its ONE platform alarm. */
+    get timers(): Timers;
+    /** This incarnation's generation. Zero until the first turn adopted it. */
+    get generation(): number;
+    /**
+     * The named durable retry outbox, its drain registered as a timer reason
+     * on first call. One instance per name; later calls return the first and
+     * ignore their policy argument.
+     *
+     * Create outboxes in the CONSTRUCTOR. A queued row survives an instance
+     * reset, but the dispatcher drops a fired reason no handler answers
+     * (rollback forward-compat) — an outbox first created inside a request
+     * path is not registered when the next incarnation's alarm fires, and
+     * its queued rows sit until some later `queue()` happens to re-arm.
+     */
+    outbox<M>(name: string, policy: OutboxPolicy<M>): Outbox<M>;
+    /** The named append-only event journal. One instance per name. */
+    journal<P>(name: string): Journal<P>;
+    /** Leased facets: disposal retires (storage wiped), `detach()` keeps it. */
+    get facets(): FacetPool;
+    /**
+     * The process fabric over this actor's substrate. Declare the substrate
+     * by overriding {@link processHost}; the fabric is built once, on first
+     * use.
+     */
+    get processes(): ProcessFabric;
+    /** The substrate {@link processes} runs on. Override to declare one. */
+    protected processHost(): ProcessHost;
+    /** A watermark memo: derive a cheap key, compare, rebuild only on change. */
+    derived<T, C = void>(watermark: (context: C) => string | number, build: (context: C, key: string | number) => T, hooks?: DerivedHooks): Derived<T, C>;
+    /** The async memo; a watermark or build failure serves the last good value. */
+    derivedAsync<T, C = void>(watermark: (context: C) => Promise<string | number>, build: (context: C, key: string | number) => Promise<T>, hooks?: DerivedAsyncHooks): DerivedAsync<T, C>;
+    /**
+     * Typed, validated per-connection state over the WebSocket attachment,
+     * hibernation-durable. partyserver owns the accept (tag connections via
+     * `getConnectionTags`); this reads, writes, and addresses by tag. To
+     * replace-on-reconnect, close the other holders of the identity tag in
+     * `onConnect`.
+     *
+     * Hibernation-only: the state rides the hibernatable socket attachment,
+     * and partyserver's non-hibernating connections neither wrap nor persist
+     * it — so a non-hibernating actor is refused here, not corrupted later.
+     */
+    connections<T>(schema: z.ZodType<T>): TypedConnections<T>;
+    /**
+     * A fenced-work journal whose recovery is pumped on the first turn of
+     * every incarnation — reconnects after a reset included. The host defines
+     * what a launch is and how to re-drive it; call once, in the constructor.
+     */
+    protected fenceWork<R extends FencedWorkRecord>(host: FencedWorkHost<R>): FencedWork<R>;
+    /**
+     * Defer async reconciliation to the first turn of this incarnation —
+     * never the init gate. Safe to call from the constructor; that is the
+     * point.
+     */
+    protected deferToColdStart(task: () => Promise<unknown>): void;
+}
+//# sourceMappingURL=actor.d.ts.map

package/dist/actor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actor.d.ts","sourceRoot":"","sources":["../src/actor.ts"],"names":[],"mappings":"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"}