@happyvertical/smrt-app-shell 0.60.18 → 0.61.0

package/dist/engine/publish.d.ts

@@ -0,0 +1,100 @@
+import type { AppDefinition, FieldDef, Step } from './definition.ts';
+import type { VersionRecord } from './store.ts';
+/** What a draft hands to a publish: its base and the versions made since, oldest first. */
+export interface DraftChain {
+    baseVersion: number;
+    base: VersionRecord;
+    versions: VersionRecord[];
+}
+/** Stable JSON: object keys sorted, so equal values give equal text. */
+export declare function canonical(v: unknown): string;
+/**
+ * Identity of what a publish would apply: the live version it starts from and,
+ * per draft version, its summary, definition and steps. The numbers the
+ * versions get in live are not part of it.
+ */
+export declare function chainDigest(liveVersion: number, chain: DraftChain): string;
+export interface FieldChange {
+    field: string;
+    from: FieldDef;
+    to: FieldDef;
+}
+export interface ModelDiff {
+    fieldsAdded: string[];
+    fieldsRemoved: string[];
+    fieldsChanged: FieldChange[];
+}
+export interface DefinitionDiff {
+    modelsAdded: string[];
+    modelsRemoved: string[];
+    /** Per model that exists on both sides and differs. */
+    models: Record<string, ModelDiff>;
+    recipesAdded: string[];
+    recipesRemoved: string[];
+}
+/** What changes from `from` to `to`. A rename shows as a removal and an addition; the steps say it was a rename. */
+export declare function diffDefinitions(from: AppDefinition, to: AppDefinition): DefinitionDiff;
+export interface PublishMethod {
+    model: string;
+    name: string;
+    description: string;
+    params: Record<string, unknown>;
+    /** The full code: what the owner approves is what will run. */
+    code: string;
+    change: 'added' | 'changed' | 'unchanged';
+}
+/** Every method of `to`, in full, marked against `from`. */
+export declare function listMethods(from: AppDefinition, to: AppDefinition): PublishMethod[];
+/** Names of the archive tables a chain's steps create. */
+export declare function archivedTables(steps: Step[]): string[];
+export declare const JOURNAL_FILE = "publish-journal.json";
+export declare const ASIDE = ".prepublish";
+export interface PublishJournal {
+    format: 1;
+    /** Live's version before, the version the publish ends on. */
+    oldVersion: number;
+    finalVersion: number;
+    rehearsal: string;
+    /** The prepublish snapshot (a retained copy of the old data). */
+    snapshot: string;
+    startedAt: string;
+}
+export declare function readJournal(dataDir: string): PublishJournal | null;
+/** Written whole and renamed into place, so it is either absent or complete. */
+export declare function writeJournal(dataDir: string, j: PublishJournal): void;
+export declare function removeJournal(dataDir: string): void;
+/**
+ * A `.prepublish` file already there is not ours (a publish removes its own):
+ * restoring it later would replace live's data with it. So a publish refuses
+ * to start, and `restoreAside` is only ever run for asides this publish made.
+ */
+export declare function assertNoAside(dataDir: string): void;
+/**
+ * Rename live's database files to `<name>.prepublish`. The side files go
+ * first and `app.db` last, so "app.db is gone" always means "all of them are
+ * aside". Refuses if an aside file is already there (a leftover to look at).
+ */
+export declare function moveAside(dataDir: string): void;
+/**
+ * Put the `.prepublish` files back. If the main file was moved aside, whatever
+ * stands at the live names now belongs to the new database and is removed
+ * first (a foreign -wal next to the old file would be replayed into it).
+ * If only side files were moved, the main file never left: just rename them back.
+ * Safe to run at any point of the swap, and again.
+ */
+export declare function restoreAside(dataDir: string): void;
+export declare function dropAside(dataDir: string): void;
+export declare function rehearsalDirName(): string;
+export declare function makeRehearsalDir(dataDir: string): string;
+/** Remove one rehearsal directory, only if it is one of ours (by name). */
+export declare function removeRehearsal(dataDir: string, dir: string): void;
+/**
+ * Run at every host start, before the app opens: finish or undo an interrupted
+ * publish. The new database was never written to before the store committed
+ * (the change queue is held until then), so:
+ *  - the store already points at the published version: the publish happened,
+ *    only the leftovers are removed;
+ *  - otherwise the old files come back.
+ * Returns what it did.
+ */
+export declare function reconcilePublish(dataDir: string, current: number | null): 'none' | 'rolled-forward' | 'rolled-back';

package/dist/engine/publish.js

@@ -0,0 +1,218 @@
+// Publishing a draft: the pure parts (digest, definition diff) and the file
+// operations around the guarded swap of `app.db`, with their crash recovery.
+//
+// The swap, in order (host.ts drives it; every step has a tested failure path):
+//   1. a consistent copy of live is rehearsed with the draft's changes
+//   2. a snapshot of live is taken (snapshots/<ts>-0-migrate-prepublish.db)
+//   3. the journal is written, the live worker is retired
+//   4. live's app.db (+ -wal/-shm/-journal) is renamed to `<name>.prepublish`,
+//      the rehearsed file is renamed to app.db        <- the crash window
+//   5. the new worker starts, the versions are written to the store
+//   6. the journal and the `.prepublish` files are removed
+// Before step 4 nothing of live has changed; after a failure in 4 or 5 the
+// `.prepublish` files are renamed back, so app.db is byte-for-byte what it was.
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { EngineError } from "./errors.js";
+/** Stable JSON: object keys sorted, so equal values give equal text. */
+export function canonical(v) {
+    const norm = (x) => Array.isArray(x)
+        ? x.map(norm)
+        : x && typeof x === 'object'
+            ? Object.fromEntries(Object.entries(x)
+                .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+                .map(([k, val]) => [k, norm(val)]))
+            : x;
+    return JSON.stringify(norm(v));
+}
+/**
+ * Identity of what a publish would apply: the live version it starts from and,
+ * per draft version, its summary, definition and steps. The numbers the
+ * versions get in live are not part of it.
+ */
+export function chainDigest(liveVersion, chain) {
+    return createHash('sha256')
+        .update(canonical({
+        liveVersion,
+        base: chain.base.definition,
+        versions: chain.versions.map((r) => ({
+            author: r.author,
+            summary: r.summary,
+            definition: r.definition,
+            steps: r.migration?.steps ?? [],
+        })),
+    }))
+        .digest('hex');
+}
+const keys = (o) => Object.keys(o ?? {});
+/** What changes from `from` to `to`. A rename shows as a removal and an addition; the steps say it was a rename. */
+export function diffDefinitions(from, to) {
+    const out = {
+        modelsAdded: keys(to.models).filter((m) => !(m in from.models)),
+        modelsRemoved: keys(from.models).filter((m) => !(m in to.models)),
+        models: {},
+        recipesAdded: to.recipes.filter((r) => !from.recipes.includes(r)),
+        recipesRemoved: from.recipes.filter((r) => !to.recipes.includes(r)),
+    };
+    for (const m of keys(to.models)) {
+        if (!(m in from.models))
+            continue;
+        const a = from.models[m].fields;
+        const b = to.models[m].fields;
+        const d = {
+            fieldsAdded: keys(b).filter((f) => !(f in a)),
+            fieldsRemoved: keys(a).filter((f) => !(f in b)),
+            fieldsChanged: keys(b)
+                .filter((f) => f in a && canonical(a[f]) !== canonical(b[f]))
+                .map((f) => ({ field: f, from: a[f], to: b[f] })),
+        };
+        if (d.fieldsAdded.length ||
+            d.fieldsRemoved.length ||
+            d.fieldsChanged.length)
+            out.models[m] = d;
+    }
+    return out;
+}
+/** Every method of `to`, in full, marked against `from`. */
+export function listMethods(from, to) {
+    const out = [];
+    for (const [model, md] of Object.entries(to.models))
+        for (const [name, meth] of Object.entries(md.methods ?? {})) {
+            const before = from.models[model]?.methods?.[name];
+            out.push({
+                model,
+                name,
+                description: meth.description,
+                params: meth.params ?? {},
+                code: meth.code,
+                change: !before
+                    ? 'added'
+                    : canonical(before) === canonical(meth)
+                        ? 'unchanged'
+                        : 'changed',
+            });
+        }
+    return out;
+}
+/** Names of the archive tables a chain's steps create. */
+export function archivedTables(steps) {
+    return steps.flatMap((s) => (s.op === 'archiveTable' ? [s.archivedAs] : []));
+}
+// ---------- the journal and the file swap ----------
+export const JOURNAL_FILE = 'publish-journal.json';
+export const ASIDE = '.prepublish';
+/** The files that make up a SQLite database, main file LAST (see {@link moveAside}). */
+const DB_PARTS = ['app.db-journal', 'app.db-shm', 'app.db-wal', 'app.db'];
+const REHEARSAL = /^publish-rehearsal-[A-Za-z0-9]+$/;
+export function readJournal(dataDir) {
+    const file = join(dataDir, JOURNAL_FILE);
+    if (!existsSync(file))
+        return null;
+    try {
+        const j = JSON.parse(readFileSync(file, 'utf8'));
+        if (j?.format !== 1 ||
+            !Number.isInteger(j.oldVersion) ||
+            !Number.isInteger(j.finalVersion))
+            throw new Error('bad shape');
+        return j;
+    }
+    catch {
+        // Guessing about a half-finished swap could lose data: refuse to start.
+        throw new EngineError(`${JOURNAL_FILE} in ${dataDir} is unreadable, so an interrupted publish cannot be recovered automatically; restore app.db from the .prepublish files or the newest migrate-prepublish snapshot`, 'refused');
+    }
+}
+/** Written whole and renamed into place, so it is either absent or complete. */
+export function writeJournal(dataDir, j) {
+    const tmp = join(dataDir, `${JOURNAL_FILE}.tmp`);
+    writeFileSync(tmp, JSON.stringify(j));
+    renameSync(tmp, join(dataDir, JOURNAL_FILE));
+}
+export function removeJournal(dataDir) {
+    rmSync(join(dataDir, JOURNAL_FILE), { force: true });
+    rmSync(join(dataDir, `${JOURNAL_FILE}.tmp`), { force: true });
+}
+/**
+ * A `.prepublish` file already there is not ours (a publish removes its own):
+ * restoring it later would replace live's data with it. So a publish refuses
+ * to start, and `restoreAside` is only ever run for asides this publish made.
+ */
+export function assertNoAside(dataDir) {
+    for (const n of DB_PARTS)
+        if (existsSync(join(dataDir, n + ASIDE)))
+            throw new EngineError(`${n + ASIDE} is already there from an earlier publish; not overwriting it`, 'refused');
+}
+/**
+ * Rename live's database files to `<name>.prepublish`. The side files go
+ * first and `app.db` last, so "app.db is gone" always means "all of them are
+ * aside". Refuses if an aside file is already there (a leftover to look at).
+ */
+export function moveAside(dataDir) {
+    assertNoAside(dataDir);
+    for (const n of DB_PARTS)
+        if (existsSync(join(dataDir, n)))
+            renameSync(join(dataDir, n), join(dataDir, n + ASIDE));
+}
+/**
+ * Put the `.prepublish` files back. If the main file was moved aside, whatever
+ * stands at the live names now belongs to the new database and is removed
+ * first (a foreign -wal next to the old file would be replayed into it).
+ * If only side files were moved, the main file never left: just rename them back.
+ * Safe to run at any point of the swap, and again.
+ */
+export function restoreAside(dataDir) {
+    if (existsSync(join(dataDir, `app.db${ASIDE}`)))
+        for (const n of DB_PARTS)
+            rmSync(join(dataDir, n), { force: true });
+    for (const n of DB_PARTS)
+        if (existsSync(join(dataDir, n + ASIDE)))
+            renameSync(join(dataDir, n + ASIDE), join(dataDir, n));
+}
+export function dropAside(dataDir) {
+    for (const n of DB_PARTS)
+        rmSync(join(dataDir, n + ASIDE), { force: true });
+}
+export function rehearsalDirName() {
+    return `publish-rehearsal-${createHash('sha1')
+        .update(`${process.hrtime.bigint()}${Math.random()}`)
+        .digest('hex')
+        .slice(0, 10)}`;
+}
+export function makeRehearsalDir(dataDir) {
+    const dir = join(dataDir, rehearsalDirName());
+    mkdirSync(join(dir, 'final'), { recursive: true });
+    return dir;
+}
+/** Remove one rehearsal directory, only if it is one of ours (by name). */
+export function removeRehearsal(dataDir, dir) {
+    if (dirname(dir) === dataDir && REHEARSAL.test(basename(dir)))
+        rmSync(dir, { recursive: true, force: true });
+}
+/**
+ * Run at every host start, before the app opens: finish or undo an interrupted
+ * publish. The new database was never written to before the store committed
+ * (the change queue is held until then), so:
+ *  - the store already points at the published version: the publish happened,
+ *    only the leftovers are removed;
+ *  - otherwise the old files come back.
+ * Returns what it did.
+ */
+export function reconcilePublish(dataDir, current) {
+    const journal = readJournal(dataDir);
+    let did = 'none';
+    if (journal) {
+        if (current === journal.finalVersion) {
+            dropAside(dataDir);
+            did = 'rolled-forward';
+        }
+        else {
+            restoreAside(dataDir);
+            did = 'rolled-back';
+        }
+        removeJournal(dataDir);
+    }
+    for (const e of readdirSync(dataDir, { withFileTypes: true }))
+        if (e.isDirectory() && REHEARSAL.test(e.name))
+            rmSync(join(dataDir, e.name), { recursive: true, force: true });
+    return did;
+}

package/dist/engine/store.d.ts

@@ -25,6 +25,13 @@ export interface VersionStore {
     markPurged(version: number): Promise<void>;
     /** Highest version number held, or -1 when empty. */
     maxVersion(): Promise<number>;
+    /**
+     * Optional: append `records` and make `current` the current version as ONE
+     * atomic change (all or nothing). A publish uses it when present; without it
+     * the host appends one by one and a failure part-way leaves the appended
+     * records behind as unreachable history (they are never current).
+     */
+    commit?(records: VersionRecord[], current: number): Promise<void>;
 }
 export declare class MemoryVersionStore implements VersionStore {
     private cur;
@@ -36,4 +43,5 @@ export declare class MemoryVersionStore implements VersionStore {
     append(record: VersionRecord): Promise<void>;
     markPurged(version: number): Promise<void>;
     maxVersion(): Promise<number>;
+    commit(records: VersionRecord[], current: number): Promise<void>;
 }

package/dist/engine/store.js

@@ -29,4 +29,12 @@ export class MemoryVersionStore {
     async maxVersion() {
         return this.records.size ? Math.max(...this.records.keys()) : -1;
     }
+    async commit(records, current) {
+        for (const r of records)
+            if (this.records.has(r.version))
+                throw new Error(`version ${r.version} already exists`);
+        for (const r of records)
+            this.records.set(r.version, structuredClone(r));
+        this.cur = current;
+    }
 }

package/dist/engine/worker-protocol.d.ts

@@ -1,4 +1,4 @@
-export declare const WORKER_OPS: readonly ["list", "get", "create", "update", "remove", "runMethod", "tools", "callTool", "rest", "snapshot", "previewConversion", "countValues", "countRows", "countArchives", "countOverwrites", "pruneSnapshots", "purgeArchives", "importRecords"];
+export declare const WORKER_OPS: readonly ["list", "get", "create", "update", "remove", "runMethod", "tools", "callTool", "rest", "snapshot", "copyTo", "previewConversion", "countValues", "countRows", "countArchives", "countOverwrites", "pruneSnapshots", "purgeArchives", "importRecords"];
 export type WorkerOp = (typeof WORKER_OPS)[number];
 export type WorkerCall = {
     id: number;

package/dist/engine/worker-protocol.js

@@ -9,6 +9,7 @@ export const WORKER_OPS = [
     'callTool',
     'rest',
     'snapshot',
+    'copyTo',
     'previewConversion',
     'countValues',
     'countRows',

package/dist/lib/objects/App.d.ts

@@ -45,15 +45,56 @@ export declare class App extends SmrtObject {
     static exportTemplate(includeRecords?: boolean): Promise<BuilderResult>;
     /** Import a template, replacing the definition (risky if it has code). */
     static importTemplate(data: Record<string, unknown>): Promise<BuilderResult>;
+    /**
+     * Undo every change after `version` in one step (the history leading to now).
+     * Waits for the owner's approval when any of them converted a field's type.
+     * "Undo this publish": pass the version before the publish's first one.
+     */
+    static undoTo(version: number): Promise<BuilderResult>;
+    /**
+     * Start a draft: a test copy of the app (with its records) to build in while
+     * the live app keeps working. Live structure is frozen until the draft is
+     * published or discarded. One draft at a time.
+     */
+    static startDraft(name?: string): Promise<import("../server/drafts.ts").DraftInfo>;
+    /**
+     * Preview publishing the open draft: what changes, the SQL, every method's
+     * code, and a digest. Read only.
+     */
+    static previewPublish(): Promise<import("../../engine/host.ts").PublishPreview>;
+    /**
+     * Publish the open draft's changes to the live app. ALWAYS waits for the
+     * owner's approval (`pending_approval`); it applies only if the draft is
+     * unchanged since this preview. Pass `expect` (the preview's digest) to
+     * refuse a draft that changed since you looked.
+     */
+    static publishDraft(expect?: string): Promise<import("../server/approvals.ts").PendingApproval>;
+    /** Throw the open draft away (waits for the owner's approval). The live app is not changed. */
+    static discardDraft(): Promise<import("../server/approvals.ts").PendingApproval>;
     /** The models, fields and methods of the app now. */
     static describe(): Promise<{
         name: string;
         version: number;
         recipes: string[];
         models: Record<string, import("../../engine/definition.ts").DescribedModel>;
+        mode: "live" | "draft";
+        draft: import("../server/drafts.ts").DraftInfo | null;
+        frozen: boolean;
     }>;
     /** Every version of the app, newest last. */
-    static history(): Promise<import("../../engine/host.ts").VersionSummary[]>;
+    static history(): Promise<{
+        publish: {
+            draftId: string;
+            name: string;
+        } | null;
+        version: number;
+        parent: number | null;
+        author: string;
+        summary: string;
+        createdAt: string;
+        purged: boolean;
+        current: boolean;
+    }[]>;
 }
 export declare class AppCollection extends SmrtCollection<App> {
     static readonly _itemClass: typeof App;

package/dist/lib/objects/App.js

@@ -7,8 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { field, SmrtCollection, SmrtObject, smrt, } from '@happyvertical/smrt-core';
 import { EngineError, } from "../../engine/index.js";
 import { runCommand } from "../server/builder.js";
-import { getHost } from "../server/host.js";
+import { describeCopy, historyFor, previewDraft, requestDiscard, requestPublish, startDraft, } from "../server/drafts.js";
 import { assertOwner } from "../server/owner.js";
+import { currentScope } from "../server/target.js";
 // The decorator config must be a literal: the smrt() scanner reads it
 // statically (a shared constant would be invisible to it and every generated
 // surface would default to full CRUD). The collection repeats it exactly:
@@ -42,9 +43,13 @@ function str(value, what) {
     return value;
 }
 const FIELD_EXAMPLE = "{type: 'integer'}";
+/**
+ * Run a builder command on the copy the REQUEST named (`withScope`, entered by
+ * the REST route or the tool dispatch; all-live when nothing entered it).
+ */
 async function run(command) {
     const owner = await assertOwner();
-    return runCommand(command, owner.id);
+    return runCommand(command, owner.id, currentScope().structure);
 }
 /**
  * The shell's one app: a singleton row holding the current definition. Its
@@ -166,15 +171,58 @@ let App = class App extends SmrtObject {
             data: obj(data, 'data', '{format: 1, definition: {...}}'),
         });
     }
+    /**
+     * Undo every change after `version` in one step (the history leading to now).
+     * Waits for the owner's approval when any of them converted a field's type.
+     * "Undo this publish": pass the version before the publish's first one.
+     */
+    static async undoTo(version) {
+        const n = Number(version);
+        if (!Number.isInteger(n))
+            throw new EngineError('version must be a whole number', 'invalid');
+        return run({ type: 'undoTo', version: n });
+    }
+    /**
+     * Start a draft: a test copy of the app (with its records) to build in while
+     * the live app keeps working. Live structure is frozen until the draft is
+     * published or discarded. One draft at a time.
+     */
+    static async startDraft(name) {
+        const owner = await assertOwner();
+        return startDraft(name, owner.id);
+    }
+    /**
+     * Preview publishing the open draft: what changes, the SQL, every method's
+     * code, and a digest. Read only.
+     */
+    static async previewPublish() {
+        await assertOwner();
+        return (await previewDraft()).preview;
+    }
+    /**
+     * Publish the open draft's changes to the live app. ALWAYS waits for the
+     * owner's approval (`pending_approval`); it applies only if the draft is
+     * unchanged since this preview. Pass `expect` (the preview's digest) to
+     * refuse a draft that changed since you looked.
+     */
+    static async publishDraft(expect) {
+        const owner = await assertOwner();
+        return requestPublish(expect, owner.id);
+    }
+    /** Throw the open draft away (waits for the owner's approval). The live app is not changed. */
+    static async discardDraft() {
+        const owner = await assertOwner();
+        return requestDiscard(owner.id);
+    }
     /** The models, fields and methods of the app now. */
     static async describe() {
         await assertOwner();
-        return (await getHost()).describe();
+        return describeCopy(currentScope().structure);
     }
     /** Every version of the app, newest last. */
     static async history() {
         await assertOwner();
-        return (await getHost()).versions();
+        return historyFor(currentScope().structure);
     }
 };
 __decorate([
@@ -207,6 +255,11 @@ App = __decorate([
                 'importTemplate',
                 'describe',
                 'history',
+                'undoTo',
+                'startDraft',
+                'previewPublish',
+                'publishDraft',
+                'discardDraft',
             ],
         },
         mcp: {
@@ -226,6 +279,11 @@ App = __decorate([
                 'importTemplate',
                 'describe',
                 'history',
+                'undoTo',
+                'startDraft',
+                'previewPublish',
+                'publishDraft',
+                'discardDraft',
             ],
         },
         cli: {
@@ -245,6 +303,11 @@ App = __decorate([
                 'importTemplate',
                 'describe',
                 'history',
+                'undoTo',
+                'startDraft',
+                'previewPublish',
+                'publishDraft',
+                'discardDraft',
             ],
         },
         operationPermissions: {
@@ -263,6 +326,11 @@ App = __decorate([
             importTemplate: { action: 'update' },
             describe: { action: 'read' },
             history: { action: 'read' },
+            undoTo: { action: 'update' },
+            startDraft: { action: 'update' },
+            previewPublish: { action: 'read' },
+            publishDraft: { action: 'update' },
+            discardDraft: { action: 'update' },
         },
     })
 ], App);

package/dist/lib/objects/AppDraft.d.ts

@@ -0,0 +1,31 @@
+import { SmrtCollection, SmrtObject } from '@happyvertical/smrt-core';
+export type AppDraftStatus = 'starting' | 'open' | 'published' | 'discarded';
+/**
+ * One draft of the user app (shell.db): a test copy the owner builds in while
+ * the live app keeps serving records. At most one is `starting` or `open` at a
+ * time. Rows are never deleted: a draft ends as `published` (with the live
+ * versions it became) or `discarded`. The copy itself is a directory the
+ * engine made (`<data root>/user-app-draft`); this row is the shell's record
+ * of it. Written only by `drafts.ts` and the version stores; no generated
+ * surface.
+ */
+export declare class AppDraft extends SmrtObject {
+    name: string;
+    /** `starting` while the copy is made, `open`, then `published` or `discarded`. */
+    status: AppDraftStatus;
+    /** The live version the draft was copied from, `-1` until it is. */
+    baseVersion: number;
+    /** The draft's own current version (its store's pointer), `-1` for none yet. */
+    currentVersion: number;
+    createdBy: string;
+    createdAt: string;
+    /** When it was published or discarded. */
+    endedAt: string;
+    /** The live version numbers a publish created, JSON array text. */
+    publishedVersions: string;
+    /** Why it ended without publishing ("start failed", "discarded"), if worth saying. */
+    note: string;
+}
+export declare class AppDraftCollection extends SmrtCollection<AppDraft> {
+    static readonly _itemClass: typeof AppDraft;
+}

package/dist/lib/objects/AppDraft.js

@@ -0,0 +1,73 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { field, SmrtCollection, SmrtObject, smrt, } from '@happyvertical/smrt-core';
+/**
+ * One draft of the user app (shell.db): a test copy the owner builds in while
+ * the live app keeps serving records. At most one is `starting` or `open` at a
+ * time. Rows are never deleted: a draft ends as `published` (with the live
+ * versions it became) or `discarded`. The copy itself is a directory the
+ * engine made (`<data root>/user-app-draft`); this row is the shell's record
+ * of it. Written only by `drafts.ts` and the version stores; no generated
+ * surface.
+ */
+let AppDraft = class AppDraft extends SmrtObject {
+    name = 'Draft';
+    /** `starting` while the copy is made, `open`, then `published` or `discarded`. */
+    status = 'starting';
+    /** The live version the draft was copied from, `-1` until it is. */
+    baseVersion = -1;
+    /** The draft's own current version (its store's pointer), `-1` for none yet. */
+    currentVersion = -1;
+    createdBy = '';
+    createdAt = '';
+    /** When it was published or discarded. */
+    endedAt = '';
+    /** The live version numbers a publish created, JSON array text. */
+    publishedVersions = '';
+    /** Why it ended without publishing ("start failed", "discarded"), if worth saying. */
+    note = '';
+};
+__decorate([
+    field({ type: 'text', required: true })
+], AppDraft.prototype, "name", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppDraft.prototype, "status", void 0);
+__decorate([
+    field({ type: 'integer' })
+], AppDraft.prototype, "baseVersion", void 0);
+__decorate([
+    field({ type: 'integer' })
+], AppDraft.prototype, "currentVersion", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppDraft.prototype, "createdBy", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppDraft.prototype, "createdAt", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppDraft.prototype, "endedAt", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppDraft.prototype, "publishedVersions", void 0);
+__decorate([
+    field({ type: 'text' })
+], AppDraft.prototype, "note", void 0);
+AppDraft = __decorate([
+    smrt({
+        tableName: 'app_drafts',
+        api: false,
+        mcp: false,
+        cli: false,
+        conflictColumns: ['id'],
+    })
+], AppDraft);
+export { AppDraft };
+export class AppDraftCollection extends SmrtCollection {
+    static _itemClass = AppDraft;
+}