@melite/estate-drafts 0.0.0-stage → 0.1.5-pre-alpha

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+import type { Context, Plugin } from "@deepseek-ai/cordis";
+import type { DraftsConfig } from "./store.js";
+export { BenchRemoteService, DraftsRemoteService, installBenchChangeSeam } from "./remote.js";
+export { resolveStorageRoot, openDraftsDomain, } from "./store.js";
+export type { DraftsConfig } from "./store.js";
+export { DRAFT_ID_RE, draftIdOk } from "./spec.js";
+export type { CharacterRecord } from "./spec.js";
+export type { BenchChangeSeam } from "./bench.js";
+export { setBenchChangeSeam } from "./bench.js";
+export type { BenchEnsureRow, BenchGetRow, DraftListResult, DraftListRow, } from "./remote.js";
+export declare const name = "estate-drafts";
+export declare function apply(ctx: Context, config?: DraftsConfig): void;
+declare const plugin: Plugin;
+export default plugin;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,17 @@
+import { BenchRemoteService, DraftsRemoteService } from "./remote.js";
+import { DraftsDomainSeatService } from "./store.js";
+export { BenchRemoteService, DraftsRemoteService, installBenchChangeSeam } from "./remote.js";
+export { resolveStorageRoot, openDraftsDomain, } from "./store.js";
+export { DRAFT_ID_RE, draftIdOk } from "./spec.js";
+export { setBenchChangeSeam } from "./bench.js";
+export const name = "estate-drafts";
+export function apply(ctx, config = {}) {
+    // the domain seat mounts FIRST — the remote services' writers open
+    // the drafts domain through it (openDraftsDomain probes this seat)
+    new DraftsDomainSeatService(ctx, config);
+    new DraftsRemoteService(ctx);
+    new BenchRemoteService(ctx);
+}
+const plugin = { name, apply };
+export default plugin;
+//# sourceMappingURL=index.js.map

package/lib/remote.d.ts

@@ -0,0 +1,325 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { STAGE_PATCH_KEYS, type StagePatchKey } from "@melite/contracts/benchStage";
+export { STAGE_PATCH_KEYS, type StagePatchKey };
+import { type LaneMigration } from "./bench.js";
+import type { BenchEnsureRow, BenchGetRow, BenchPatchRow, BenchReorderRow, BenchRewireRow, BenchClearRow, BenchStageRow, BenchUndoRow } from "./bench.js";
+export type { BenchEnsureRow, BenchGetRow, BenchPatchRow, BenchReorderRow, BenchRewireRow, BenchStageRow, BenchUndoRow, } from "./bench.js";
+/** Endpoint `drafts/patch` answer — the old door's delivered envelope:
+ *  a missing doc/stage is delivered:false + reason (a DOMAIN outcome,
+ *  never an error); a landing patch reports the patched key set and
+ *  the bench revision it landed at (the CAS law's re-read handle). */
+export interface DraftPatchRow {
+    draftId: string;
+    stageId: string;
+    delivered: boolean;
+    reason?: string;
+    patched?: string[];
+    rev?: number;
+}
+/** draft_id_ok: 1..96 chars of [A-Za-z0-9_-] (the composer mint). */
+/** One listed draft — the index row (recency-ordered by the caller). */
+export interface DraftListRow {
+    readonly draft_id: string;
+    readonly model: string;
+    readonly name: string;
+}
+/** The list result: rows capped at 600, count total pre-cap. */
+export interface DraftListResult {
+    readonly count: number;
+    readonly drafts: readonly DraftListRow[];
+}
+/** JSON at the wire — the constrained face of every open doc. The
+ *  Typert generator's boundary law refuses unconstrained `unknown`
+ *  data in @Remote signatures (assertRemoteJsonType: "Remote
+ *  boundary contains unconstrained unknown data"); open card
+ *  payloads (stage params, results, history) are honestly JSON all
+ *  the way down, so the wire face says exactly that. */
+
+
+
+
+
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+/** Endpoint `drafts/get` answer — the stored draft doc (open,
+ *  card-authored) with its stages resolved for the wire. */
+export type DraftGetRow = {
+    readonly [key: string]: JsonValue;
+};
+/** Endpoint `drafts/patch` body — the door's FIXED key set (unknown
+ *  keys refuse at admission with the old door's voice; STAGE_PATCH_KEYS).
+ *  Optional: presence IS the write; a null params value is the
+ *  merge-patch DELETE (the layered-params law); a null health value
+ *  is the same DELETE (the recovery clear, LOW-23). */
+export type DraftStagePatch = {
+    params?: JsonValue;
+    result?: JsonValue;
+    runStatus?: JsonValue;
+    health?: JsonValue;
+    inputs?: JsonValue;
+    inputOutputs?: JsonValue;
+};
+/** The bench verbs' wire body — an open JSON doc (each verb's
+ *  admission law constrains its own keys at the door: stage,
+ *  expect_rev, index, binding, …). */
+export type BenchDoc = {
+    readonly [key: string]: JsonValue;
+};
+/** The drafts' Remote failure codes, merged into the protocol's one
+ *  vocabulary (cookbook §2: declaration merging, next to the throw). */
+declare module "@deepseek-ai/dsh-typert-protocol" {
+    interface RemoteErrorDetailsMap {
+        /** The id fails the [A-Za-z0-9_-]{1,96} draft law. */
+        "draft/bad-id": {
+            readonly draftId: string;
+        };
+        /** No stored draft carries that id. */
+        "draft/not-found": {
+            readonly draftId: string;
+        };
+        /** The storage open refused an otherwise valid call. */
+        "draft/store-failed": Record<string, never>;
+        /** The stage id is empty/non-string (the patch door). */
+        "draft/bad-stage-id": {
+            readonly stageId: string;
+        };
+        /** The patch body is not a plain object (the patch door). */
+        "draft/bad-patch": Record<string, never>;
+        /** Keys outside the door's fixed set (the old voice names them). */
+        "draft/patch-unknown-keys": {
+            readonly unknown: readonly string[];
+        };
+        /** The domain write refused (put failed at the medium). */
+        "draft/cannot-persist": Record<string, never>;
+    }
+}
+declare module "@deepseek-ai/cordis" {
+    interface Context {
+        draftsRemote: DraftsRemoteService;
+        benchRemote: BenchRemoteService;
+    }
+    interface Events {
+        /**
+         * A bench write landed. Emitted after every successful bench verb
+         * (and after the drafts-patch door's bench-shaped write).
+         * @mode emit
+         * @param session - the bench session whose doc changed.
+         */
+        "bench.changed": (session: string) => void;
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export declare function installBenchChangeSeam(ctx: Context): () => void;
+/** ── THE OUTPUT HISTORY HELPERS (stroke 40) ──────────────────────
+ *  resultOutputUrls now lives in trail.ts (the cycle-free seam) and
+ *  is re-exported below with the trail laws. ───────────────────── */
+export declare function sameResultOutputs(a: unknown, b: unknown): boolean;
+
+
+
+
+export { canonicalOutputUrl, resultOutputUrls, isTerminalTrailWord as isTerminalWord, trailDedupe } from "./trail.js";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export declare function admissionOf(ctx: Context): ((card: string, params: Record<string, unknown>, provenance: unknown) => void) | undefined;
+
+
+
+
+
+export declare const RESTORED_PROVENANCE: unique symbol;
+
+
+
+
+
+
+
+
+
+
+
+export declare const RESTORED_WIRE_SPELLING = "restored";
+
+
+
+
+
+
+
+
+
+
+
+
+
+export declare function laneAdmissionOf(ctx: Context): ((card: string, params: Record<string, unknown>, provenance: unknown) => void) | undefined;
+
+
+
+
+
+
+
+
+export declare function laneMigrationOf(ctx: Context): LaneMigration | undefined;
+
+
+
+
+
+export declare function benchAdmissionOf(ctx: Context): ((card: string, params: Record<string, unknown>, provenance: unknown) => void) | undefined;
+export declare class DraftsRemoteService extends TypertRemoteService {
+    
+
+
+
+
+
+
+
+    
+
+
+
+
+    private benchAdmit;
+    constructor(ctx: Context);
+    /** Endpoint `drafts/list` — the domain index, recency DESC. */
+    remoteExportList(signal: AbortSignal): Promise<DraftListResult>;
+    /** Endpoint `drafts/get` — one doc by id. */
+    remoteExportGet(draftId: string, signal: AbortSignal): Promise<DraftGetRow>;
+    /** The in-process API the adapters above delegate to. */
+    list(signal: AbortSignal): Promise<DraftListResult>;
+    /** The in-process API the adapter above delegates to. */
+    get(draftId: string, signal: AbortSignal): Promise<Record<string, unknown>>;
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    remoteExportPatch(draftId: string, stageId: string, patch: DraftStagePatch, expectRev: number | null, signal: AbortSignal): Promise<DraftPatchRow>;
+    /** The patch arm the adapter above delegates to — one write
+     *  transaction on the draft's own key, shared with the bench
+     *  verbs (the round-14 race audit's R3: the author arm's
+     *  spread-copy of the log forked against their in-place push). */
+    patch(draftId: string, stageId: string, patch: Record<string, unknown>, expectRev: number | null, signal: AbortSignal): Promise<DraftPatchRow>;
+    private patchBody;
+}
+/** The bench Remote owner: ensure/get over the same drafts domain
+ *  (the bench doc IS a draft doc, id "bench-<session>"). */
+export declare class BenchRemoteService extends TypertRemoteService {
+    constructor(ctx: Context);
+    /** Endpoint `bench/get` — one session's bench block as the row. */
+    remoteExportGet(sessionKey: string, signal: AbortSignal): Promise<BenchGetRow>;
+    
+
+
+
+
+
+
+
+
+
+    subscribe(sessionKey: string, signal: AbortSignal): AsyncIterable<BenchGetRow>;
+    /** Endpoint `bench/ensure` — birth or load (the only creating arm). */
+    remoteExportEnsure(doc: BenchDoc, signal: AbortSignal): Promise<BenchEnsureRow>;
+    /** The in-process API the adapters above delegate to. Classified
+     *  bench failures pass through untouched; only the open itself
+     *  wraps as bench/store-failed. */
+    get(session: string, signal: AbortSignal): Promise<BenchGetRow>;
+    /** The in-process API the adapter above delegates to. */
+    ensure(doc: BenchDoc, signal: AbortSignal): Promise<BenchEnsureRow>;
+    /** Endpoint `bench/patch` — params merge (+result/runStatus) with
+     *  CAS + log. */
+    remoteExportPatch(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchPatchRow>;
+    /** Endpoint `bench/add-stage` — append a card stage. */
+    remoteExportAddStage(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchStageRow>;
+    /** Endpoint `bench/remove-stage` — splice one stage out. */
+    remoteExportRemoveStage(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchStageRow>;
+    
+
+
+
+    remoteExportClear(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchClearRow>;
+    /** Endpoint `bench/rewire` — set or clear one input binding. */
+    remoteExportRewire(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchRewireRow>;
+    
+
+    remoteExportReorder(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchReorderRow>;
+    
+
+    remoteExportGroup(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchStageRow>;
+    /** Endpoint `bench/ungroup` — spill a compound's children back. */
+    remoteExportUngroup(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchStageRow>;
+    /** Endpoint `bench/undo` — walk the log tail, apply inverses. */
+    remoteExportUndo(sessionKey: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchUndoRow>;
+    /** The in-process APIs the adapters above delegate to. The
+     *  domain's classified failures pass through untouched; only the
+     *  open itself wraps as bench/store-failed. */
+    private open;
+    patch(session: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchPatchRow>;
+    addStage(session: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchStageRow>;
+    removeStage(session: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchStageRow>;
+    clear(session: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchClearRow>;
+    rewire(session: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchRewireRow>;
+    undo(session: string, doc: BenchDoc, signal: AbortSignal): Promise<BenchUndoRow>;
+}
+//# sourceMappingURL=remote.d.ts.map