@tenonhq/dovetail-core 0.0.104 → 0.0.105

package/dist/reconcileCommand.js

@@ -0,0 +1,409 @@
+"use strict";
+// `dove reconcile` — make a developer's personal ServiceNow instance match the
+// git branch they just checked out: the deliberate, diff-gated inverse of
+// `dove watch`.
+//
+// Modes:
+//   (default)          read-only dry run — snapshot branch (on-disk) + live
+//                      instance, classify create/update/delete, surface drift,
+//                      report schema drift (report-only), print the report.
+//   --write-baseline   establish the per-instance merge-base from current live
+//                      state (no record changes). Run this once before --apply.
+//   --apply [--force]  apply the safe subset: record UPDATE (branch -> instance)
+//                      and tracked DELETE. Refuses if the instance drifted since
+//                      baseline (unless --force). CREATE is deferred to Phase 3;
+//                      schema stays report-only (a ServiceNow ceiling).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileCommand = reconcileCommand;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const dovetail_schema_1 = require("@tenonhq/dovetail-schema");
+const Logger_1 = require("./Logger");
+const FileLogger_1 = require("./FileLogger");
+const commands_1 = require("./commands");
+const ConfigManager = __importStar(require("./config"));
+const snClient_1 = require("./snClient");
+const appUtils_1 = require("./appUtils");
+const recordSource_1 = require("./reconcile/recordSource");
+const recordDiff_1 = require("./reconcile/recordDiff");
+const baseline_1 = require("./reconcile/baseline");
+const report_1 = require("./reconcile/report");
+const applyPlan_1 = require("./reconcile/applyPlan");
+const deleteOrder_1 = require("./reconcile/deleteOrder");
+const gitignore_1 = require("./reconcile/gitignore");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+function requireCreds() {
+    const { SN_USER = "", SN_PASSWORD = "", SN_INSTANCE = "" } = process.env;
+    if (!SN_USER || !SN_PASSWORD || !SN_INSTANCE) {
+        throw new Error("Missing ServiceNow credentials. Ensure SN_INSTANCE, SN_USER, and SN_PASSWORD are set in your .env file or environment.");
+    }
+    return { SN_USER, SN_PASSWORD, SN_INSTANCE };
+}
+function normalizeInstance(instance) {
+    return instance.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+function resolveScopes(args) {
+    const config = ConfigManager.getConfig();
+    const configScopes = config.scopes ? Object.keys(config.scopes) : [];
+    if (configScopes.length === 0) {
+        throw new Error("No scopes configured in dove.config.js. Add scopes to the 'scopes' object in your configuration.");
+    }
+    if (args.scope) {
+        if (configScopes.indexOf(args.scope) === -1) {
+            throw new Error('Scope "' +
+                args.scope +
+                '" is not configured in dove.config.js. Available scopes: ' +
+                configScopes.join(", "));
+        }
+        return [args.scope];
+    }
+    return configScopes;
+}
+async function currentBranch() {
+    try {
+        const { stdout } = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+        return stdout.trim();
+    }
+    catch (e) {
+        return "";
+    }
+}
+// Best-effort schema arm: only runs when a snapshot exists for this instance.
+async function buildSchemaDiffs(options) {
+    const { creds, instance, scopes } = options;
+    const rootDir = ConfigManager.getRootDir();
+    const outputDir = path_1.default.join(rootDir, "schema");
+    let snapshots = [];
+    try {
+        snapshots = await (0, dovetail_schema_1.listSnapshots)({ outputDir, instance });
+    }
+    catch (e) {
+        return { diffs: {}, skipped: "schema snapshot lookup failed" };
+    }
+    if (snapshots.length === 0) {
+        return {
+            diffs: {},
+            skipped: "no schema snapshot for " +
+                instance +
+                " — run `dove schema pull --snapshot <label>` to include schema drift",
+        };
+    }
+    const fromRef = path_1.default.basename(snapshots[0].dir);
+    let liveDir;
+    try {
+        const tmpDir = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), "dove-reconcile-schema-"));
+        await (0, dovetail_schema_1.pullSchema)({
+            instance: creds.SN_INSTANCE,
+            username: creds.SN_USER,
+            password: creds.SN_PASSWORD,
+            outputDir: tmpDir,
+            scopes,
+        });
+        liveDir = tmpDir;
+    }
+    catch (e) {
+        return { diffs: {}, skipped: "live schema pull failed" };
+    }
+    const fromDir = await (0, dovetail_schema_1.resolveSnapshotDir)({ ref: fromRef, outputDir, instance });
+    const diffs = {};
+    for (const scope of scopes) {
+        try {
+            const from = await (0, dovetail_schema_1.readSchemaTree)({ dir: fromDir, scope });
+            const to = await (0, dovetail_schema_1.readSchemaTree)({ dir: liveDir, scope });
+            diffs[scope] = (0, dovetail_schema_1.diffSchemas)({ from, to, fromRef, toRef: "live", scope });
+        }
+        catch (e) {
+            FileLogger_1.fileLogger.debug("reconcile: schema diff failed for scope " + scope);
+        }
+    }
+    return { diffs, skipped: null };
+}
+// Collect the on-disk field file paths for the records an apply will UPDATE, so
+// the existing build + update-set push pipeline can overwrite the instance with
+// branch content.
+async function collectUpdateFilePaths(scope, updates) {
+    const sourcePath = ConfigManager.getSourcePathForScope(scope);
+    const paths = [];
+    for (const change of updates) {
+        const recordDir = path_1.default.join(sourcePath, change.table, change.name);
+        let entries;
+        try {
+            entries = await fs_1.promises.readdir(recordDir);
+        }
+        catch (e) {
+            FileLogger_1.fileLogger.debug("reconcile: update record dir missing " + recordDir);
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry === "metaData.json") {
+                continue;
+            }
+            const full = path_1.default.join(recordDir, entry);
+            try {
+                const stat = await fs_1.promises.stat(full);
+                if (stat.isFile()) {
+                    paths.push(full);
+                }
+            }
+            catch (e) {
+                // ignore unreadable entry
+            }
+        }
+    }
+    return paths;
+}
+async function applyUpdates(scope, updates) {
+    if (updates.length === 0) {
+        return { pushed: 0, failures: [] };
+    }
+    const paths = await collectUpdateFilePaths(scope, updates);
+    if (paths.length === 0) {
+        return { pushed: 0, failures: [] };
+    }
+    const recs = await (0, appUtils_1.getAppFileList)(paths);
+    const results = await (0, appUtils_1.pushFiles)(recs);
+    const failures = [];
+    let pushed = 0;
+    for (const result of results) {
+        if (result.success) {
+            pushed++;
+        }
+        else {
+            failures.push(result.message);
+        }
+    }
+    return { pushed, failures };
+}
+async function applyDeletes(scope, deletes) {
+    if (deletes.length === 0) {
+        return [];
+    }
+    const client = (0, snClient_1.defaultClient)();
+    return (0, deleteOrder_1.runMultiPassDeletes)(deletes, async (change) => {
+        try {
+            const response = await client.deleteRecord({
+                table: change.table,
+                sys_id: change.sys_id,
+                scope,
+            });
+            let data = response.data;
+            if (data && data.result) {
+                data = data.result;
+            }
+            if (data && (data.error || data.success === false)) {
+                return { ok: false, error: data.error || "delete rejected" };
+            }
+            return { ok: true };
+        }
+        catch (e) {
+            return { ok: false, error: e instanceof Error ? e.message : String(e) };
+        }
+    });
+}
+// Capture current live state across every scope into a fresh baseline + ensure
+// the baseline file is gitignored in the consumer project.
+async function recaptureBaseline(options) {
+    const all = [];
+    for (const scope of options.scopes) {
+        try {
+            const live = await (0, recordSource_1.loadLiveRecords)(scope);
+            for (const record of live) {
+                all.push(record);
+            }
+        }
+        catch (e) {
+            Logger_1.logger.warn("Baseline capture failed for scope " + scope + " — skipped.");
+        }
+    }
+    (0, baseline_1.writeBaseline)(options.rootDir, (0, baseline_1.baselineFromLive)(options.instance, all));
+    const update = (0, gitignore_1.ensureGitignored)(options.rootDir, baseline_1.BASELINE_FILENAME);
+    if (update.changed) {
+        Logger_1.logger.info("Added " + baseline_1.BASELINE_FILENAME + " to .gitignore.");
+    }
+    return all.length;
+}
+async function writeBaselineMode(options) {
+    Logger_1.logger.info("Establishing reconcile baseline for " + options.instance + "...");
+    const count = await recaptureBaseline(options);
+    Logger_1.logger.success("Baseline established: " + count + " record(s) captured to " + baseline_1.BASELINE_FILENAME + ".");
+}
+async function reconcileCommand(args) {
+    (0, commands_1.setLogLevel)(args);
+    const typedArgs = args;
+    let creds;
+    try {
+        creds = requireCreds();
+    }
+    catch (e) {
+        Logger_1.logger.error(e instanceof Error ? e.message : String(e));
+        process.exitCode = 1;
+        return;
+    }
+    const instance = normalizeInstance(creds.SN_INSTANCE);
+    const scopes = resolveScopes(typedArgs);
+    const rootDir = ConfigManager.getRootDir();
+    // --write-baseline: establish the merge-base and stop.
+    if (typedArgs.writeBaseline) {
+        await writeBaselineMode({ rootDir, instance, scopes });
+        return;
+    }
+    const branchRef = await currentBranch();
+    const baseline = (0, baseline_1.readBaseline)(rootDir, instance);
+    const baselineIds = (0, baseline_1.baselineSysIds)(baseline);
+    // Schema arm is on by default; --no-schema disables it.
+    let schemaDiffs = {};
+    let schemaSkippedReason = null;
+    if (typedArgs.schema === false) {
+        schemaSkippedReason = "schema diff disabled (--no-schema)";
+    }
+    else {
+        const schemaResult = await buildSchemaDiffs({ creds, instance, scopes });
+        schemaDiffs = schemaResult.diffs;
+        schemaSkippedReason = schemaResult.skipped;
+    }
+    const scopeData = [];
+    const scopeResults = [];
+    for (const scope of scopes) {
+        Logger_1.logger.info("Reconciling scope: " + scope + "...");
+        let branch;
+        let live;
+        try {
+            branch = await (0, recordSource_1.loadBranchRecords)(scope);
+            live = await (0, recordSource_1.loadLiveRecords)(scope);
+        }
+        catch (e) {
+            Logger_1.logger.error("Failed to load records for scope " +
+                scope +
+                ": " +
+                (e instanceof Error ? e.message : String(e)));
+            continue;
+        }
+        const diff = (0, recordDiff_1.diffRecords)({ branch, live, baselineSysIds: baselineIds });
+        const dirty = (0, baseline_1.computeDirty)({ baseline, live });
+        scopeData.push({ scope, live, diff, dirty });
+        scopeResults.push({
+            scope,
+            diff,
+            dirty,
+            hasBaseline: baseline !== null,
+            schema: schemaDiffs[scope] || null,
+        });
+    }
+    const report = (0, report_1.formatReconcileReport)({
+        instanceHost: instance,
+        branchRef,
+        scopes: scopeResults,
+        schemaSkippedReason,
+    });
+    // console.log so the report's own layout survives the winston line-wrapper.
+    console.log(report);
+    if (!typedArgs.apply) {
+        return;
+    }
+    await applyMode({ typedArgs, scopeData, baseline: baseline !== null, rootDir, instance, scopes });
+}
+async function applyMode(options) {
+    const { typedArgs, scopeData } = options;
+    const force = typedArgs.force === true;
+    const plans = scopeData.map((data) => ({
+        scope: data.scope,
+        plan: (0, applyPlan_1.buildApplyPlan)({
+            diff: data.diff,
+            dirty: data.dirty,
+            hasBaseline: options.baseline,
+            force,
+        }),
+    }));
+    const refused = plans.filter((entry) => entry.plan.refuse);
+    if (refused.length > 0) {
+        Logger_1.logger.error("Apply refused:");
+        for (const entry of refused) {
+            Logger_1.logger.error("  [" + entry.scope + "] " + entry.plan.refuseReason);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    Logger_1.logger.info("");
+    Logger_1.logger.info("Applying reconcile (branch -> instance)...");
+    let totalUpdated = 0;
+    let totalDeleted = 0;
+    const failures = [];
+    for (const entry of plans) {
+        const { scope, plan } = entry;
+        if (plan.deferredCreates.length > 0) {
+            Logger_1.logger.info("  [" +
+                scope +
+                "] " +
+                plan.deferredCreates.length +
+                " create(s) deferred — CREATE ships in Phase 3.");
+        }
+        const updateResult = await applyUpdates(scope, plan.updates);
+        totalUpdated += updateResult.pushed;
+        for (const failure of updateResult.failures) {
+            failures.push("[" + scope + "] update: " + failure);
+        }
+        const deleteOutcomes = await applyDeletes(scope, plan.deletes);
+        for (const outcome of deleteOutcomes) {
+            if (outcome.ok) {
+                totalDeleted++;
+            }
+            else {
+                failures.push("[" + scope + "] delete " + outcome.change.table + "/" + outcome.change.name + ": " + (outcome.error || "failed"));
+            }
+        }
+    }
+    // Re-capture the baseline from the now-converged instance.
+    await recaptureBaseline({
+        rootDir: options.rootDir,
+        instance: options.instance,
+        scopes: options.scopes,
+    });
+    Logger_1.logger.info("");
+    Logger_1.logger.success("Applied: " + totalUpdated + " updated, " + totalDeleted + " deleted.");
+    if (failures.length > 0) {
+        Logger_1.logger.error(failures.length + " operation(s) failed:");
+        for (const failure of failures) {
+            Logger_1.logger.error("  " + failure);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/tests/reconcileApplyPlan.test.js

@@ -0,0 +1,98 @@
+"use strict";
+// Tests for the pure apply-plan decision: refuse-if-dirty, baseline gating,
+// --force semantics, and delete eligibility by disposition.
+Object.defineProperty(exports, "__esModule", { value: true });
+const applyPlan_1 = require("../reconcile/applyPlan");
+const change = (over) => ({
+    table: "sys_script",
+    scope: "x_cadso_core",
+    name: over.sys_id,
+    fieldDeltas: [],
+    ...over,
+});
+const diff = (over) => ({
+    creates: [],
+    updates: [],
+    deletes: [],
+    unchangedCount: 0,
+    ...over,
+});
+const dirty = (sys_id) => ({
+    sys_id,
+    table: "sys_script",
+    name: sys_id,
+    reason: "changed-since-baseline",
+});
+describe("buildApplyPlan — refusal gating", () => {
+    it("refuses with no baseline", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({ diff: diff({}), dirty: [], hasBaseline: false, force: false });
+        expect(plan.refuse).toBe(true);
+        expect(plan.refuseReason).toContain("--write-baseline");
+    });
+    it("refuses on drift without --force", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({}),
+            dirty: [dirty("a")],
+            hasBaseline: true,
+            force: false,
+        });
+        expect(plan.refuse).toBe(true);
+        expect(plan.refuseReason).toContain("changed on the instance since baseline");
+    });
+    it("does not refuse on drift with --force", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({}),
+            dirty: [dirty("a")],
+            hasBaseline: true,
+            force: true,
+        });
+        expect(plan.refuse).toBe(false);
+    });
+    it("does not refuse when clean", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({ diff: diff({}), dirty: [], hasBaseline: true, force: false });
+        expect(plan.refuse).toBe(false);
+    });
+});
+describe("buildApplyPlan — what applies", () => {
+    it("includes updates and defers creates", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({
+                updates: [change({ sys_id: "u", kind: "update" })],
+                creates: [change({ sys_id: "c", kind: "create" })],
+            }),
+            dirty: [],
+            hasBaseline: true,
+            force: false,
+        });
+        expect(plan.updates.map((u) => u.sys_id)).toEqual(["u"]);
+        expect(plan.deferredCreates.map((c) => c.sys_id)).toEqual(["c"]);
+    });
+    it("applies only tracked deletes; keeps local-new and no-baseline", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({
+                deletes: [
+                    change({ sys_id: "t", kind: "delete", deleteDisposition: "tracked" }),
+                    change({ sys_id: "l", kind: "delete", deleteDisposition: "local-new" }),
+                    change({ sys_id: "n", kind: "delete", deleteDisposition: "no-baseline" }),
+                ],
+            }),
+            dirty: [],
+            hasBaseline: true,
+            force: false,
+        });
+        expect(plan.deletes.map((d) => d.sys_id)).toEqual(["t"]);
+        expect(plan.skippedDeletes.map((d) => d.sys_id).sort()).toEqual(["l", "n"]);
+    });
+    it("--force still never deletes local-new records", () => {
+        const plan = (0, applyPlan_1.buildApplyPlan)({
+            diff: diff({
+                deletes: [change({ sys_id: "mine", kind: "delete", deleteDisposition: "local-new" })],
+            }),
+            dirty: [dirty("other")],
+            hasBaseline: true,
+            force: true,
+        });
+        expect(plan.deletes).toHaveLength(0);
+        expect(plan.skippedDeletes.map((d) => d.sys_id)).toEqual(["mine"]);
+    });
+});

package/dist/tests/reconcileBaseline.test.js

@@ -0,0 +1,103 @@
+"use strict";
+// Tests for the reconcile baseline: defensive read (degrades to null, never
+// throws), write round-trip, the pure dirty-check, and live-snapshot capture.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const baseline_1 = require("../reconcile/baseline");
+const live = (sys_id, updatedOn) => ({
+    table: "sys_script",
+    scope: "x_cadso_core",
+    name: sys_id,
+    sys_id,
+    updatedOn,
+    fields: {},
+});
+function tmpRoot() {
+    return fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "dove-reconcile-base-"));
+}
+describe("readBaseline — defensive", () => {
+    it("returns null when the file is absent", () => {
+        expect((0, baseline_1.readBaseline)(tmpRoot(), "tenonworkstudio")).toBeNull();
+    });
+    it("returns null on malformed JSON", () => {
+        const root = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root, baseline_1.BASELINE_FILENAME), "{not json");
+        expect((0, baseline_1.readBaseline)(root, "tenonworkstudio")).toBeNull();
+    });
+    it("returns null on wrong version or non-string record map", () => {
+        const root = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root, baseline_1.BASELINE_FILENAME), JSON.stringify({ version: 2, instance: "x", records: {} }));
+        expect((0, baseline_1.readBaseline)(root, "x")).toBeNull();
+        const root2 = tmpRoot();
+        fs_1.default.writeFileSync(path_1.default.join(root2, baseline_1.BASELINE_FILENAME), JSON.stringify({ version: 1, instance: "x", records: { a: 5 } }));
+        expect((0, baseline_1.readBaseline)(root2, "x")).toBeNull();
+    });
+    it("returns null when the baseline was captured against another instance", () => {
+        const root = tmpRoot();
+        (0, baseline_1.writeBaseline)(root, {
+            version: 1,
+            instance: "tenonworkshop",
+            records: { a: "t" },
+        });
+        expect((0, baseline_1.readBaseline)(root, "tenonworkstudio")).toBeNull();
+    });
+    it("round-trips a valid baseline", () => {
+        const root = tmpRoot();
+        (0, baseline_1.writeBaseline)(root, {
+            version: 1,
+            instance: "tenonworkstudio",
+            records: { a: "2026-06-01 00:00:00" },
+        });
+        const got = (0, baseline_1.readBaseline)(root, "tenonworkstudio");
+        expect(got).not.toBeNull();
+        expect(got.records.a).toBe("2026-06-01 00:00:00");
+    });
+});
+describe("baselineFromLive + baselineSysIds", () => {
+    it("captures sys_id -> updatedOn from the live set", () => {
+        const base = (0, baseline_1.baselineFromLive)("tenonworkstudio", [
+            live("a", "t1"),
+            live("b", "t2"),
+        ]);
+        expect(base.records).toEqual({ a: "t1", b: "t2" });
+        expect(base.instance).toBe("tenonworkstudio");
+    });
+    it("baselineSysIds is null for a null baseline and a Set otherwise", () => {
+        expect((0, baseline_1.baselineSysIds)(null)).toBeNull();
+        const set = (0, baseline_1.baselineSysIds)({ version: 1, instance: "x", records: { a: "t" } });
+        expect(set).not.toBeNull();
+        expect(set.has("a")).toBe(true);
+    });
+});
+describe("computeDirty", () => {
+    it("returns [] with no baseline", () => {
+        expect((0, baseline_1.computeDirty)({ baseline: null, live: [live("a", "t2")] })).toEqual([]);
+    });
+    it("flags a baseline record whose live updatedOn moved", () => {
+        const dirty = (0, baseline_1.computeDirty)({
+            baseline: { version: 1, instance: "x", records: { a: "t1", b: "t1" } },
+            live: [live("a", "t2"), live("b", "t1")],
+        });
+        expect(dirty).toHaveLength(1);
+        expect(dirty[0]).toMatchObject({ sys_id: "a", reason: "changed-since-baseline" });
+    });
+    it("does not flag records absent from the baseline (those are deletes/creates, not drift)", () => {
+        const dirty = (0, baseline_1.computeDirty)({
+            baseline: { version: 1, instance: "x", records: {} },
+            live: [live("new", "t9")],
+        });
+        expect(dirty).toEqual([]);
+    });
+    it("ignores empty timestamps rather than false-flagging", () => {
+        const dirty = (0, baseline_1.computeDirty)({
+            baseline: { version: 1, instance: "x", records: { a: "" } },
+            live: [live("a", "t2")],
+        });
+        expect(dirty).toEqual([]);
+    });
+});

package/dist/tests/reconcileDeleteOrder.test.js

@@ -0,0 +1,70 @@
+"use strict";
+// Tests for the multi-pass delete loop: clean deletes, emergent FK ordering
+// (a record blocked until its dependent is gone), and a genuine failure that
+// survives a no-progress pass and is reported.
+Object.defineProperty(exports, "__esModule", { value: true });
+const deleteOrder_1 = require("../reconcile/deleteOrder");
+const del = (sys_id) => ({
+    kind: "delete",
+    table: "sys_script",
+    scope: "x_cadso_core",
+    sys_id,
+    name: sys_id,
+    fieldDeltas: [],
+    deleteDisposition: "tracked",
+});
+describe("runMultiPassDeletes", () => {
+    it("deletes everything in a single clean pass", async () => {
+        const calls = [];
+        const exec = async (c) => {
+            calls.push(c.sys_id);
+            return { ok: true };
+        };
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([del("a"), del("b")], exec);
+        expect(out.every((o) => o.ok)).toBe(true);
+        expect(calls.sort()).toEqual(["a", "b"]);
+    });
+    it("resolves FK ordering: parent succeeds only after the child is gone", async () => {
+        // "parent" cannot delete while "child" still exists.
+        const deleted = new Set();
+        const exec = async (c) => {
+            if (c.sys_id === "parent" && !deleted.has("child")) {
+                return { ok: false, error: "still referenced by child" };
+            }
+            deleted.add(c.sys_id);
+            return { ok: true };
+        };
+        // parent is attempted first, fails, then succeeds on the pass after child.
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([del("parent"), del("child")], exec);
+        expect(out.filter((o) => o.ok).map((o) => o.change.sys_id).sort()).toEqual([
+            "child",
+            "parent",
+        ]);
+        expect(out.every((o) => o.ok)).toBe(true);
+    });
+    it("reports a record that fails for a non-ordering reason", async () => {
+        const exec = async (c) => {
+            if (c.sys_id === "locked") {
+                return { ok: false, error: "ACL blocked" };
+            }
+            return { ok: true };
+        };
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([del("ok"), del("locked")], exec);
+        const failed = out.filter((o) => !o.ok);
+        expect(failed).toHaveLength(1);
+        expect(failed[0].change.sys_id).toBe("locked");
+        expect(failed[0].error).toBe("ACL blocked");
+    });
+    it("treats a thrown executor error as a failure", async () => {
+        const exec = async () => {
+            throw new Error("network down");
+        };
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([del("a")], exec);
+        expect(out[0].ok).toBe(false);
+        expect(out[0].error).toBe("network down");
+    });
+    it("returns [] for no changes", async () => {
+        const out = await (0, deleteOrder_1.runMultiPassDeletes)([], async () => ({ ok: true }));
+        expect(out).toEqual([]);
+    });
+});