@melite/estate-drafts 0.0.0-stage → 0.1.4-alpha

package/lib/spec.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+/** One drafts-domain record: the doc plus the recency column the
+ *  list arm orders by (the file-mtime equivalent — seconds). */
+declare const DraftRecordSchema: z.ZodObject<{
+    updated_at: z.ZodNumber;
+    doc: z.ZodObject<{
+        draft_id: z.ZodString;
+        status: z.ZodString;
+        createdAt: z.ZodNumber;
+        completedAt: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+        intent: z.ZodString;
+        stages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type DraftRecord = z.infer<typeof DraftRecordSchema>;
+/** The draft-id law (editor_runs.818-822 heritage): 1..96 chars,
+ *  [A-Za-z0-9_-] ASCII only, path-safe. THE SSOT — the queue's
+ *  submit gate and the drafts remote both test this one address
+ *  (the queue re-exports it; gateway-core's copy is dead). */
+export declare const DRAFT_ID_RE: RegExp;
+/** The id's PATTERN and its bound, published so every gate that
+ *  admits a draft id enforces the SAME rule (the census's H13: the
+ *  queue's copy had no cap, so a long id passed one door and was
+ *  refused by the next with a different voice). */
+export declare const DRAFT_ID_PATTERN: RegExp;
+export declare const DRAFT_ID_MAX_LEN = 96;
+/** draft_id_ok (the doors' hand-loop drop-in): the law, one voice. */
+export declare function draftIdOk(draftId: string): boolean;
+/** The drafts domain (unit dir `drafts/`, version 1). */
+export declare const draftsDomainSpec: {
+    name: string;
+    version: number;
+    layout: "per-record";
+    invalidRecords: "backup-and-skip";
+    global: {
+        schema: z.ZodNumber;
+        initial: number;
+    };
+    tables: {
+        docs: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            updated_at: number;
+            doc: {
+                [x: string]: unknown;
+                draft_id: string;
+                status: string;
+                createdAt: number;
+                completedAt: number | null;
+                intent: string;
+                stages: {
+                    [x: string]: unknown;
+                    id: string;
+                }[];
+            };
+        }>;
+    };
+};
+export type DraftsDomainSpec = typeof draftsDomainSpec;
+export {};
+//# sourceMappingURL=spec.d.ts.map

package/lib/spec.js

@@ -0,0 +1,57 @@
+
+//
+// The domain truth for draft docs: table `docs` keyed by draft id
+// (DRAFT_ID_RE admits path-safe chars only, so the identity codec
+// holds — no b64u here), one record per draft (large, sparse,
+// individually disposable), schema-failing records backed up and
+// skipped by the facility (`invalidRecords: 'backup-and-skip'`).
+// The global slot is the one-time legacy-import marker: 0 until the
+// legacy drafts tree has been imported, the import epoch (ms) after.
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+/** One draft doc — the composer's shape: six contract keys plus
+ *  caller extras verbatim. THE SERVE READ IS DELIBERATELY LOOSE
+ *  (the write doors are strict; this read hands the composer's own
+ *  extras back, pinned by bench-coverage's "extras ride the loose
+ *  schema" row) — a looseObject needs no .passthrough() on top. */
+const DraftDocSchema = z.looseObject({
+    draft_id: z.string(),
+    status: z.string(),
+    createdAt: z.number(),
+    completedAt: z.union([z.number(), z.null()]),
+    intent: z.string(),
+    stages: z.array(z.looseObject({ id: z.string() })),
+});
+/** One drafts-domain record: the doc plus the recency column the
+ *  list arm orders by (the file-mtime equivalent — seconds). */
+const DraftRecordSchema = z.object({
+    updated_at: z.number().int(),
+    doc: DraftDocSchema,
+});
+/** The draft-id law (editor_runs.818-822 heritage): 1..96 chars,
+ *  [A-Za-z0-9_-] ASCII only, path-safe. THE SSOT — the queue's
+ *  submit gate and the drafts remote both test this one address
+ *  (the queue re-exports it; gateway-core's copy is dead). */
+export const DRAFT_ID_RE = /^[A-Za-z0-9_-]{1,96}$/;
+/** The id's PATTERN and its bound, published so every gate that
+ *  admits a draft id enforces the SAME rule (the census's H13: the
+ *  queue's copy had no cap, so a long id passed one door and was
+ *  refused by the next with a different voice). */
+export const DRAFT_ID_PATTERN = DRAFT_ID_RE;
+export const DRAFT_ID_MAX_LEN = 96;
+/** draft_id_ok (the doors' hand-loop drop-in): the law, one voice. */
+export function draftIdOk(draftId) {
+    return DRAFT_ID_RE.test(draftId);
+}
+/** The drafts domain (unit dir `drafts/`, version 1). */
+export const draftsDomainSpec = defineDomain({
+    name: "drafts",
+    version: 1,
+    layout: "per-record",
+    invalidRecords: "backup-and-skip",
+    global: { schema: z.number().int(), initial: 0 },
+    tables: {
+        docs: domainTable(DraftRecordSchema),
+    },
+});
+//# sourceMappingURL=spec.js.map

package/lib/store.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { Domain } from "@deepseek-ai/dsh-storage-domain";
+import type { DraftsDomainSpec } from "./spec.js";
+/** Env override for the unit-file root (an env seam, never a hardcode). */
+export declare const STORAGE_ROOT_ENV: string;
+/** The json backend's unit-file root: `<stateRoot>/storage`. */
+export declare function resolveStorageRoot(): string;
+
+
+
+export declare function openDraftsDomain(ctx: Context): Promise<Domain<DraftsDomainSpec>>;
+//# sourceMappingURL=store.d.ts.map

package/lib/store.js

@@ -0,0 +1,106 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { draftsDomainSpec } from "./spec.js";
+/** Env override for the unit-file root (an env seam, never a hardcode). */
+export const STORAGE_ROOT_ENV = "MELITE_STORAGE_ROOT";
+/** Env seam for the state root the legacy drafts tree hangs under. */
+const STATE_ROOT_ENV = "MELITE_STATE_ROOT";
+/** The json backend's unit-file root: `<stateRoot>/storage`. */
+export function resolveStorageRoot() {
+    const override = process.env[STORAGE_ROOT_ENV] ?? "";
+    if (override !== "")
+        return override;
+    const state = process.env[STATE_ROOT_ENV] ?? "data/runs";
+    return join(state, "storage");
+}
+/** The one-time legacy-drafts import (the pre-domain drafts tree →
+ *  the drafts domain). Unparseable/non-object legacy files skip;
+ *  schema-failing rows skip individually; the rest import. */
+async function importLegacyDrafts(drafts) {
+    const marker = drafts.global;
+    if (marker.get() !== 0)
+        return;
+    const docs = drafts.table("docs");
+    const legacyDir = join(resolveStorageRoot(), "..", "drafts");
+    let names;
+    try {
+        names = readdirSync(legacyDir);
+    }
+    catch {
+        names = [];
+    }
+    for (const name of names) {
+        if (!name.endsWith(".json"))
+            continue;
+        const did = name.slice(0, -5);
+        if (docs.get(did) !== undefined)
+            continue;
+        let doc;
+        try {
+            doc = JSON.parse(readFileSync(join(legacyDir, name), "utf8"));
+        }
+        catch {
+            continue;
+        }
+        if (typeof doc !== "object" || doc === null || Array.isArray(doc))
+            continue;
+        const rec = doc;
+        if (typeof rec["draft_id"] !== "string")
+            rec["draft_id"] = did;
+        let updated = Math.floor(Date.now() / 1000);
+        try {
+            updated = Math.floor(statSync(join(legacyDir, name)).mtimeMs / 1000);
+        }
+        catch {
+            /* unstatable imports as now — ordering stays total */
+        }
+        try {
+            await docs.put(did, {
+                updated_at: updated,
+                doc: rec,
+            });
+        }
+        catch {
+            /* a schema-failing legacy row skips; the rest import */
+        }
+    }
+    await marker.set(Date.now());
+}
+let cached = new WeakMap();
+
+
+
+export async function openDraftsDomain(ctx) {
+    const root = resolveStorageRoot();
+    // OPTIONAL-dependency probe per the tutorial's documented pattern
+    // (cordis-tutorial/03-services.md: "skip inject and probe at the
+    // use site" — property reads demand inject on loader-mounted
+    // fibers; ctx.get returns the active provider or undefined).
+    const facility = ctx.get("storageDomain");
+    if (facility === undefined || facility === null) {
+        throw new Error("[estate-drafts] storage domain facility not mounted (ctx.storageDomain)");
+    }
+    const hit = cached.get(facility);
+    if (hit !== undefined && hit.root === root)
+        return hit.ready;
+    // A foreign root never cross-writes another root's units.
+    if (hit !== undefined && hit.root !== root) {
+        throw new Error("[estate-drafts] storage serves the boot root only");
+    }
+    const ready = (async () => {
+        const drafts = await facility.open(draftsDomainSpec);
+        await importLegacyDrafts(drafts);
+        return drafts;
+    })();
+    cached.set(facility, { root, ready });
+    try {
+        return await ready;
+    }
+    catch (error) {
+        // Unconditional: one slot per facility exists at a time (a
+        // foreign root refuses above), so this rejection owns the slot.
+        cached.delete(facility);
+        throw error;
+    }
+}
+//# sourceMappingURL=store.js.map

package/lib/typert.host.d.ts

@@ -0,0 +1,3 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from FaceModel — do not edit. */
+
+export declare const TYPERT: unknown