@onlyne/lib 3.0.0 → 3.2.0

package/README.md

@@ -6,10 +6,11 @@ The protocol is specified by the draft RFCs in [`docs/rfcs`](../../docs/rfcs). T
 
 ## Run
 
-The package exports TypeScript source for a TypeScript-capable host such as Bun.
+The package compiles TypeScript source to standard ESM JavaScript and `.d.ts` declarations under `./dist/`, so Node.js (including inside `node_modules` and Electron ASAR), Bun, and TypeScript consumers load it directly without runtime type-stripping flags.
 
 ```sh
 bun install
+bun run build
 bun run check
 bun run test
 ```
@@ -34,9 +35,9 @@ export function serveOnlyne(options: NodeOptions, port: number) {
 }
 ```
 
-`options.base_url` includes `/onlyne/v3`. `FetchTransport` permits HTTP on loopback and requires HTTPS for remote hosts. The resolver supplies the remote identity, URL, and authentication headers. The authentication plugin maps each inbound request to its verified actor.
+`options.base_url` includes `/onlyne/v3` (and may be mounted under a URL path prefix such as `/nodes/<id>/onlyne/v3` when sharing a single HTTP listener across local identities). `FetchTransport` permits HTTP on loopback and requires HTTPS for remote hosts. The resolver supplies the remote identity, URL, and authentication headers. The authentication plugin maps each inbound request to its verified actor.
 
-The model calls `node.client.msg({ delivery_kind, msg, meta })`. The `decide` plugin returns a typed send, read, thread, resource, or domain action. An unavailable decision returns `decision_unavailable`. Hosts can also call the typed `threads`, `messages`, `resources`, `domains`, and `client.send` interfaces directly.
+The model calls `node.client.msg({ delivery_kind, msg, meta })`. Work-unit correlation travels as first-class `meta.work` (`{ unit, parent?, attempt? }`) on `Message['meta']` and `Action(kind: 'send')`, covered by the message identity digest. The `decide` plugin returns a typed send, read, thread, resource, or domain action. An unavailable decision returns `decision_unavailable`. Hosts can also call the typed `threads`, `messages`, `resources`, `domains`, and `client.send` interfaces directly.
 
 A plan whose `response` is `await` keeps `client.send` on the reply. The outcome reports `wait` as `answered`, `timed_out`, or `cancelled`, and an answered one carries `reply` with `reply_body`. The awaited tool result and the automatic attention fragment share one consumption record per `(context, ThreadRef, seq)`. A body already confirmed in that context comes back as `reply_body: 'withheld'` with the arrival facts and the original MessageRef only; a body this result rendered closes the record, so the fragment does not present it again. `runtime.confirmToolResult` reports the tool result the host observed in that context. A record no path confirmed stays open and is replayed.
 
@@ -60,6 +61,8 @@ A resource has one binding — the handler and the highest event it has confirme
 
 `client.readResources(query)` reads local resources or requests their owner's authenticated endpoint. The `ResourceReadQuery` operations are `list`, `describe`, `log`, `event`, `operations`, and `status`. The `decide` plugin can return `{ kind: 'read', scope: 'resources', query }` to use the same reader through `msg`. Reads create no operation record and do not call a resource driver.
 
+A queued entry that projects a resource event (`meta.data.resource_ref`, authenticated by that resource's owner) is checked against the binding before it is injected. If the binding names another handler, the row is settled with `settlement.via === 'handover'`; if this node may no longer read the resource, the row is settled as `undeliverable` with `reason: 'resource-unavailable'`. A transient failure leaves the row owed and is traced as `inbound.resource-check.failed`. Settlement closes the local delivery obligation. It records why delivery ended, and it does not assert that the model read the entry, so no consumption record and no todo are written.
+
 `list` accepts concrete `owners`, `page_size`, and `cursor`. Omitted `owners` selects the local node. The result contains `owners: [{ owner, page } | { owner, error }]`, so an unavailable owner remains visible beside successful pages. A cursor selects exactly one owner. The host chooses which owners to include. Other queries name `resource: { owner, id }`. `log` accepts an exclusive `since` event id, `page_size`, and `cursor`. `event` names `event_id`; `status` names `operation_id` and returns the existing operation record. The original actor can read that record after losing resource-read access. `operations` returns only the current actor's records.
 
 An operation result is `committed`, `pending`, `aborted`, or `unknown`. `aborted` means the endpoint refused or locally stopped the call and confirmed that no external effect happened; a failure whose side effect cannot be ruled out is `unknown`, keeps the original error in `details`, and stays owed to `node.resources.recover()`, which asks the driver for the outcome by `operation_id`. A caller that stops waiting gets `unknown` while the external call keeps running, and a later driver outcome settles that record. A retried operation is asked for its outcome, never executed a second time.

package/dist/awaited.d.ts

@@ -0,0 +1,43 @@
+import type { Entry, Message } from './types.ts';
+/** One in-flight await on a message this node sent: it lives only while its `send` runs. */
+export interface Waiter {
+    original: Message;
+    expected_author: string;
+    /** The sender-local context this await consumes its reply in; absent for a generic caller. */
+    local_context?: string;
+    outcome: Promise<Entry>;
+    settle(entry: Entry): void;
+}
+/**
+ * Live awaits and the tool-result holds they place, one registry per client. A reply already
+ * returned as a tool result holds its body in this registry until the host confirms
+ * consumption, so no automatic fragment presents the same body in that context again.
+ */
+export declare class AwaitedReplies {
+    #private;
+    /** Registered before the network call, so a reply that lands first still finds its waiter. */
+    register(record: {
+        request: {
+            message: Message;
+        };
+        expected_author: string;
+        local_context?: string;
+    }): Waiter;
+    /** An await ends when its caller leaves; a channel replaced by a newer caller stays chained. */
+    release(waiter: Waiter): void;
+    /** Releases every live await whose original this entry answers; reports how many. */
+    settle(entry: Entry): number;
+    /**
+     * Whether this entry answers an `await` that owns its body here, optionally only one whose
+     * sender-local context is `context`: a waiter still running, or a reply already returned as
+     * a tool result and not yet confirmed consumed.
+     */
+    waiting(entry: Entry, context?: string): boolean;
+    /** Holds one entry's body in one context until its consumption is confirmed. */
+    hold(entry: Entry, context: string): void;
+    /** Drops one context's hold after its path confirmed the entry's consumption. */
+    releaseContext(entry: Entry, context: string): void;
+    /** Drops every hold on one entry, for the paths that settle it without a confirmation context. */
+    forget(entry: Entry): void;
+}
+//# sourceMappingURL=awaited.d.ts.map

package/dist/awaited.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"awaited.d.ts","sourceRoot":"","sources":["../src/awaited.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjD,4FAA4F;AAC5F,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,8FAA8F;IAC9F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACxB,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC5B;AAED;;;;GAIG;AACH,qBAAa,cAAc;;IAIzB,8FAA8F;IAC9F,QAAQ,CAAC,MAAM,EAAE;QAAE,OAAO,EAAE;YAAE,OAAO,EAAE,OAAO,CAAA;SAAE,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM;IAmB5G,gGAAgG;IAChG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI7B,qFAAqF;IACrF,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAW5B;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO;IAUhD,gFAAgF;IAChF,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAMzC,iFAAiF;IACjF,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAQnD,kGAAkG;IAClG,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;CAG3B"}

package/dist/awaited.js

@@ -0,0 +1,82 @@
+import { entryKey, isReply, replyKey } from "./delivery.js";
+/**
+ * Live awaits and the tool-result holds they place, one registry per client. A reply already
+ * returned as a tool result holds its body in this registry until the host confirms
+ * consumption, so no automatic fragment presents the same body in that context again.
+ */
+export class AwaitedReplies {
+    #waiters = new Map();
+    #held = new Map();
+    /** Registered before the network call, so a reply that lands first still finds its waiter. */
+    register(record) {
+        const original = record.request.message;
+        const pending = Promise.withResolvers();
+        const slot = replyKey(original);
+        const previous = this.#waiters.get(slot);
+        const waiter = {
+            original,
+            expected_author: record.expected_author,
+            ...(record.local_context === undefined ? {} : { local_context: record.local_context }),
+            outcome: pending.promise,
+            settle(entry) {
+                previous?.settle(entry);
+                pending.resolve(entry);
+            },
+        };
+        this.#waiters.set(slot, waiter);
+        return waiter;
+    }
+    /** An await ends when its caller leaves; a channel replaced by a newer caller stays chained. */
+    release(waiter) {
+        if (this.#waiters.get(replyKey(waiter.original)) === waiter)
+            this.#waiters.delete(replyKey(waiter.original));
+    }
+    /** Releases every live await whose original this entry answers; reports how many. */
+    settle(entry) {
+        let settled = 0;
+        for (const waiter of this.#waiters.values()) {
+            if (waiter.expected_author === entry.authenticated_author && isReply(waiter.original, entry)) {
+                waiter.settle(entry);
+                settled++;
+            }
+        }
+        return settled;
+    }
+    /**
+     * Whether this entry answers an `await` that owns its body here, optionally only one whose
+     * sender-local context is `context`: a waiter still running, or a reply already returned as
+     * a tool result and not yet confirmed consumed.
+     */
+    waiting(entry, context) {
+        for (const waiter of this.#waiters.values()) {
+            if (waiter.expected_author !== entry.authenticated_author || !isReply(waiter.original, entry))
+                continue;
+            if (context !== undefined && waiter.local_context !== context)
+                continue;
+            return true;
+        }
+        const held = this.#held.get(entryKey(entry.thread_ref, entry.seq));
+        return held !== undefined && (context === undefined || held.has(context));
+    }
+    /** Holds one entry's body in one context until its consumption is confirmed. */
+    hold(entry, context) {
+        const identity = entryKey(entry.thread_ref, entry.seq);
+        const held = this.#held.get(identity) ?? new Set();
+        this.#held.set(identity, held.add(context));
+    }
+    /** Drops one context's hold after its path confirmed the entry's consumption. */
+    releaseContext(entry, context) {
+        const identity = entryKey(entry.thread_ref, entry.seq);
+        const held = this.#held.get(identity);
+        if (held === undefined)
+            return;
+        held.delete(context);
+        if (held.size === 0)
+            this.#held.delete(identity);
+    }
+    /** Drops every hold on one entry, for the paths that settle it without a confirmation context. */
+    forget(entry) {
+        this.#held.delete(entryKey(entry.thread_ref, entry.seq));
+    }
+}
+//# sourceMappingURL=awaited.js.map

package/dist/awaited.js.map

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

package/dist/client.d.ts

@@ -0,0 +1,140 @@
+import type { Context } from "./core.ts";
+import type { DeliveryPlan, Entry, LocalAttention, JoinedThread, Message, MessageQuery, MsgInput, Page, PageOptions, ThreadDescription, ThreadRef, Transport, PreparedSend, ResourceReadQuery, ResourceReadResult } from "./types.ts";
+import type { MessageService } from "./messages.ts";
+import type { ResourceService } from "./resources.ts";
+import type { ThreadService } from "./threads.ts";
+import type { DomainService } from "./domains.ts";
+import type { TrustService } from "./keys.ts";
+import type { ConsumptionRecord, MsgOptions, SendOptions, SendOutcome } from "./delivery.ts";
+export type { MsgOptions, SendOptions, SendOutcome } from "./delivery.ts";
+export declare class OnlyneClient {
+    #private;
+    /** The maintenance cadence the loop uses while durable work is pending or the host just woke it. */
+    static readonly ACTIVE_INTERVAL_MS = 2000;
+    /** The floor the loop drops to once the durable ledger holds no pending work. */
+    static readonly IDLE_INTERVAL_MS = 30000;
+    constructor(ctx: Context, transport: Transport, messages: MessageService, threads: ThreadService, resources: ResourceService, domains: DomainService, trust?: TrustService);
+    /**
+     * RFC 0017 §6: the library-owned maintenance loop. One pass runs `maintain`,
+     * `recover`, then re-arms: pending durable work keeps the active cadence, an idle
+     * ledger drops to the idle floor. Every clock read goes through the injected
+     * `MaintenanceClock`. A pass is never re-entered; a wake during a pass schedules
+     * the next tick at the active cadence. `notify` carries every pending-work change.
+     */
+    runMaintenance(): void;
+    stopMaintenance(): void;
+    /** @internal Flips the loop to its active cadence: new evidence arrived while it idled. */
+    wakeLoop(): void;
+    /** @internal Schedules an immediate maintenance pass when new inbound or grant work lands locally. */
+    wakeImmediate(): void;
+    /**
+     * Delivers one message under a caller-supplied plan. The plan is never re-derived
+     * here: RFC 0005 §2 forbids the library from choosing a delivery mode itself.
+     */
+    send(to: string, message: Message, plan: DeliveryPlan, options?: SendOptions): Promise<SendOutcome>;
+    /**
+     * Re-drives outbound records still open inside their window (RFC 0003 §3). `unknown`
+     * is terminal in meaning but the window still owns another attempt, so the window
+     * decides when to stop, not the last recorded state. A record whose window closed is
+     * settled as `unknown`, never left looking pending. Each record's own attempt series
+     * bounds the re-drive: a scheduled next attempt is respected instead of retried every
+     * pass, and a series that reached its limit stays a dead letter until an explicit
+     * re-send starts a new one. A caller invoking this directly is asking for a retry now,
+     * so it ignores the schedule; the maintenance loop's own pass respects it.
+     */
+    recover(signal?: AbortSignal): Promise<void>;
+    /**
+     * Records one inbound attention item, then acts. The durable entry and the local
+     * reply record commit before the ack (RFC 0003 §2); only then may a waiter be
+     * released, and only by an entry whose author the owner authenticated and whose
+     * author is the one expected. Invalid evidence is still acked but resolves nothing.
+     *
+     * The entry is trusted as-is: this is the runtime binding's own receive path, where
+     * the owner's authenticated response is the evidence, not a caller argument. No
+     * HTTP route accepts an `Entry` from a peer, so no peer can supply one.
+     */
+    receive(entry: Entry, obligation_id: string, context?: string): Promise<LocalAttention>;
+    /**
+     * Reconciles unacked attention for every owner this node knows (RFC 0003 §2): the
+     * `owner + thread_ref` pairs recorded when a grant notice was accepted, plus the
+     * threads this node hosts, which need no grant. The owner's authenticated attention
+     * list is the evidence; the ack goes out only after the entry is durable locally.
+     * An owner this node cannot reach is reported as a trace record, never thrown: one dead
+     * owner must not starve the rest, and a silent skip is the failure nobody can diagnose.
+     * Each (owner, thread) carries its own attempt series: a call from the maintenance pass
+     * respects the scheduled next attempt, and an exhausted series stays a dead letter so an
+     * unreachable owner costs one probe per window instead of one storm per pass. A caller
+     * invoking this directly is asking for a retry now, so it ignores the schedule — and still
+     * counts the attempt, so a caller that retries in a loop reaches the same dead letter.
+     */
+    reconcile(signal?: AbortSignal): Promise<Page<LocalAttention>>;
+    /**
+     * Delivers outstanding owner grant notices, replays owed todos and entries whose durable
+     * record never reached the model, re-asks trusted owners for the memberships they hold for
+     * this node, re-drives owed trust statements, then reconciles. Replay follows each thread's
+     * own order: `owner`, `id`, then `seq` as a number. One record that fails never starves the
+     * rest, and the failures are thrown after the pass with their records still owed for the
+     * next one. Caller-scheduled, and the only entry a host without a maintenance clock needs
+     * besides `recover`.
+     */
+    maintain(signal?: AbortSignal): Promise<void>;
+    /**
+     * Whether any durable record still needs a local pass: an unacked grant notice, an
+     * owed todo, an uninjected inbox row, or an outbound still owed an attempt. A scheduler
+     * consults this before running `maintain`, so an idle node costs no rounds; anything
+     * that flips this on (an admission, an ack, a failed delivery) also wakes the host.
+     * A dead-lettered send is terminal, and a scheduled retry counts only once it is due, so
+     * neither holds the active cadence for a peer that is simply away.
+     */
+    hasPendingWork(): Promise<boolean>;
+    /**
+     * The one call a model makes. SystemOne turns the intent into a typed action, the
+     * decision is persisted with its input, then exactly that action runs. With no
+     * usable decision the request fails: the library never picks a plan itself.
+     */
+    msg(input: MsgInput, options?: MsgOptions): Promise<unknown>;
+    prepare(input: MsgInput): Promise<PreparedSend>;
+    readResources(query: ResourceReadQuery, options?: MsgOptions): Promise<ResourceReadResult>;
+    /**
+     * `confirmConsumption(entry, context?, via = 'fragment'): Promise<void>`
+     *
+     * The host's confirmation that this entry's body was consumed by the path it names
+     * (RFC 0008 §5). One commit writes the shared consumption slot, marks every matching inbox
+     * record delivered, and records the todo this consumption owes; the host's todo hook runs
+     * outside that commit, and the todo is filed where the model saw the body. `context` names
+     * that place; with none, the context the entry landed in decides, then this node. A failing
+     * hook leaves the todo owed, so `maintain` replays it, and replaying is safe because the
+     * host commits the todo it creates. This also releases the hold an awaited tool result
+     * placed on the entry for that context.
+     */
+    confirmConsumption(entry: Entry, context?: string, via?: ConsumptionRecord['via']): Promise<void>;
+    /** `confirmToolResult(entry, context?): Promise<void>`: the same settlement for an awaited tool result. */
+    confirmToolResult(entry: Entry, context?: string): Promise<void>;
+    /**
+     * `isWaitingReply(entry, context?): boolean`
+     *
+     * Whether this entry answers an `await` that owns its body here, optionally only one whose
+     * sender-local context is `context`: a waiter still running, or a reply already returned as
+     * a tool result and not yet confirmed consumed. A host defers the automatic fragment on
+     * `true`, because the tool result either holds or already presented the same body. A
+     * cancelled wait returns no reply, so it holds nothing.
+     */
+    isWaitingReply(entry: Entry, context?: string): boolean;
+    /**
+     * The threads this node was invited into. The rows come from the records it already holds;
+     * each row is then asked of its owner through the same describe read the thread view uses,
+     * which is where the title, the state and the member table live. An owner that cannot be
+     * reached leaves the row in place with the failure attached: an unreachable peer is a
+     * reported outage, never a reason to hide a thread this node belongs to.
+     */
+    joinedThreads(options?: PageOptions, signal?: AbortSignal): Promise<Page<JoinedThread>>;
+    /** One thread's record and members: local when this node hosts it, from the owner otherwise. */
+    describeThread(ref: ThreadRef, signal?: AbortSignal): Promise<ThreadDescription>;
+    /**
+     * One page of a thread's entries, read locally when this node hosts the thread and from the
+     * owner otherwise. A member of a joined thread has no local copy of the entries, so the
+     * owner's message route is the only source that can answer for them.
+     */
+    threadEntries(ref: ThreadRef, query?: MessageQuery, signal?: AbortSignal): Promise<Page<Entry>>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

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