@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/intent/yaml.js

@@ -0,0 +1,315 @@
+/**
+ * Ticket 117 — minimal YAML subset parser for the declarative intent file.
+ *
+ * Scope (deliberately small, zero dependencies): block mappings, block
+ * sequences, plain/quoted scalars (string / number / boolean / null), comments,
+ * and single-line flow collections (`[a, b]` / `{k: v}` — desugared to the same
+ * located tree). Every node carries its source {line, column} (1-based) so the
+ * semantic layer can point validation errors at the exact offending key.
+ *
+ * Out of scope by refusal: multi-line flow collections, anchors/aliases,
+ * multi-document streams, block scalars (| and >), tags. Hitting any of these
+ * fails closed with a located yaml-syntax-error.
+ */
+export class YamlSyntaxError extends Error {
+    line;
+    column;
+    constructor(line, column, message) {
+        super(message);
+        this.line = line;
+        this.column = column;
+    }
+}
+/** Strip comments (a `#` preceded by start-of-line or whitespace, outside quotes) from a line body. */
+function stripComment(body) {
+    let inSingle = false;
+    let inDouble = false;
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        if (char === "'" && !inDouble)
+            inSingle = !inSingle;
+        else if (char === '"' && !inSingle)
+            inDouble = !inDouble;
+        else if (char === "#" && !inSingle && !inDouble && (index === 0 || /\s/.test(body[index - 1])))
+            return body.slice(0, index).trimEnd();
+    }
+    return body;
+}
+/** Split the source into non-empty logical lines with their indentation. */
+function logicalLines(text) {
+    const lines = [];
+    const rawLines = text.split(/\r?\n/);
+    for (let index = 0; index < rawLines.length; index += 1) {
+        const raw = rawLines[index];
+        const stripped = stripComment(raw);
+        if (stripped.trim().length === 0)
+            continue;
+        if (stripped.trim() === "---" || stripped.trim() === "...")
+            throw new YamlSyntaxError(index + 1, 1, "multi-document streams are not part of the intent YAML subset");
+        const indent = stripped.length - stripped.trimStart().length;
+        lines.push({ text: stripped.trim(), line: index + 1, indent });
+    }
+    return lines;
+}
+/** Parse a scalar token; quoted strings keep their content verbatim, plain tokens map to typed values. */
+function parseScalar(token, line, column) {
+    if (token.startsWith("[") || token.startsWith("{"))
+        return parseFlow(token, line, column);
+    if (token === "[]")
+        return { kind: "seq", items: [], line, column };
+    if (token === "{}")
+        return { kind: "map", entries: [], line, column };
+    if (token.startsWith('"')) {
+        if (!token.endsWith('"') || token.length < 2)
+            throw new YamlSyntaxError(line, column, "unterminated double-quoted string");
+        const inner = token.slice(1, -1);
+        if (inner.includes('"'))
+            throw new YamlSyntaxError(line, column, "unescaped quote inside double-quoted string");
+        return { kind: "scalar", value: inner, line, column };
+    }
+    if (token.startsWith("'")) {
+        if (!token.endsWith("'") || token.length < 2)
+            throw new YamlSyntaxError(line, column, "unterminated single-quoted string");
+        const inner = token.slice(1, -1);
+        if (inner.includes("'"))
+            throw new YamlSyntaxError(line, column, "unescaped quote inside single-quoted string");
+        return { kind: "scalar", value: inner, line, column };
+    }
+    if (token.startsWith("|") || token.startsWith(">"))
+        throw new YamlSyntaxError(line, column, "block scalars (| and >) are not part of the intent YAML subset");
+    if (token.includes(": "))
+        throw new YamlSyntaxError(line, column, `unexpected ": " inside plain scalar "${token}"`);
+    if (token === "true")
+        return { kind: "scalar", value: true, line, column };
+    if (token === "false")
+        return { kind: "scalar", value: false, line, column };
+    if (token === "null" || token === "~")
+        return { kind: "scalar", value: null, line, column };
+    if (/^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/.test(token))
+        return { kind: "scalar", value: Number(token), line, column };
+    if (token === "-" || token === "?")
+        throw new YamlSyntaxError(line, column, "bare dash/question mark is not a valid scalar in the intent subset");
+    if (token.startsWith("&") || token.startsWith("*"))
+        throw new YamlSyntaxError(line, column, "anchors/aliases are not part of the intent YAML subset");
+    return { kind: "scalar", value: token, line, column };
+}
+/** Split a flow body on top-level `delimiter`, respecting nested [] / {} and quotes. */
+function splitFlow(body, delimiter, line, column) {
+    const parts = [];
+    let depth = 0;
+    let inSingle = false;
+    let inDouble = false;
+    let start = 0;
+    for (let index = 0; index < body.length; index += 1) {
+        const char = body[index];
+        if (char === "'" && !inDouble)
+            inSingle = !inSingle;
+        else if (char === '"' && !inSingle)
+            inDouble = !inDouble;
+        else if (!inSingle && !inDouble) {
+            if (char === "[" || char === "{")
+                depth += 1;
+            else if (char === "]" || char === "}")
+                depth -= 1;
+            else if (char === delimiter && depth === 0) {
+                parts.push(body.slice(start, index));
+                start = index + 1;
+            }
+        }
+    }
+    if (inSingle || inDouble)
+        throw new YamlSyntaxError(line, column, "unterminated quoted string in flow collection");
+    if (depth !== 0)
+        throw new YamlSyntaxError(line, column, "unbalanced [] / {} inside a flow collection");
+    parts.push(body.slice(start));
+    return parts;
+}
+/** Strip a matching pair of surrounding quotes from a flow key. */
+function flowKey(raw) {
+    const token = raw.trim();
+    if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith("'") && token.endsWith("'")))
+        return token.slice(1, -1);
+    return token;
+}
+/**
+ * Parse a single-line flow collection. A multi-line flow collection (the closing
+ * bracket is not on the same line) is refused with a located error — the intent
+ * subset is line-oriented, so a block-style rewrite is the intended fix.
+ */
+function parseFlow(token, line, column) {
+    const open = token[0];
+    const close = open === "[" ? "]" : "}";
+    if (token[token.length - 1] !== close || token.length < 2)
+        throw new YamlSyntaxError(line, column, `flow collection must open and close on one line ("${token}"): rewrite as a block sequence/mapping`);
+    const inner = token.slice(1, -1).trim();
+    if (open === "[") {
+        if (inner === "")
+            return { kind: "seq", items: [], line, column };
+        const items = splitFlow(inner, ",", line, column).map((part) => {
+            const item = part.trim();
+            if (item === "")
+                throw new YamlSyntaxError(line, column, "empty item in flow sequence");
+            return parseScalar(item, line, column);
+        });
+        return { kind: "seq", items, line, column };
+    }
+    if (inner === "")
+        return { kind: "map", entries: [], line, column };
+    const entries = splitFlow(inner, ",", line, column).map((part) => {
+        const item = part.trim();
+        if (item === "")
+            throw new YamlSyntaxError(line, column, "empty entry in flow mapping");
+        const pair = splitFlow(item, ":", line, column);
+        if (pair.length < 2)
+            throw new YamlSyntaxError(line, column, `flow mapping entry "${item}" is missing a "key: value"`);
+        const key = flowKey(pair[0]);
+        if (key.length === 0)
+            throw new YamlSyntaxError(line, column, "empty key in flow mapping");
+        const rest = pair.slice(1).join(":").trim();
+        return { key, keyLine: line, keyColumn: column, value: rest === "" ? { kind: "scalar", value: null, line, column } : parseScalar(rest, line, column) };
+    });
+    return { kind: "map", entries, line, column };
+}
+const isMapLine = (text) => !/^[[{]/.test(text.trim()) && (/^"[^"]+"\s*:/.test(text) || /^'[^']+'\s*:/.test(text) || /^[^:\s][^:]*:(\s|$)/.test(text));
+/** Split "key: rest" — key may be quoted; rest may be empty (nested block follows). */
+function splitKey(text, line, column) {
+    const quoted = /^"([^"]+)"\s*:(.*)$/.exec(text) ?? /^'([^']+)'\s*:(.*)$/.exec(text);
+    if (quoted)
+        return { key: quoted[1], rest: quoted[2].trim() };
+    const match = /^([^:]+):\s*(.*)$/.exec(text);
+    if (!match)
+        throw new YamlSyntaxError(line, column, `expected "key: value" mapping, got "${text}"`);
+    return { key: match[1].trim(), rest: match[2].trim() };
+}
+/**
+ * Recursive block parser. Mutates `lines` in ONE place: a sequence dash
+ * carrying an inline mapping start ("- code: x") is rewritten in place to
+ * the stripped mapping line at dash-column + 2, then parsed as the nested
+ * block — the standard desugaring keeps position math trivial.
+ */
+function parseBlock(lines, cursor, indent) {
+    const first = lines[cursor.index];
+    if (first.text === "-" || first.text.startsWith("- ")) {
+        const items = [];
+        while (cursor.index < lines.length) {
+            const current = lines[cursor.index];
+            if (current.indent < indent)
+                break;
+            if (current.indent > indent)
+                throw new YamlSyntaxError(current.line, current.indent + 1, "inconsistent sequence item indentation");
+            if (current.text !== "-" && !current.text.startsWith("- "))
+                break;
+            const dashColumn = current.indent + 1;
+            const rest = current.text === "-" ? "" : current.text.slice(2).trim();
+            cursor.index += 1;
+            if (rest.length === 0) {
+                if (cursor.index < lines.length && lines[cursor.index].indent > indent)
+                    items.push(parseBlock(lines, cursor, lines[cursor.index].indent));
+                else
+                    items.push({ kind: "scalar", value: null, line: current.line, column: dashColumn });
+                continue;
+            }
+            if (isMapLine(rest)) {
+                // Desugar "- key: value" -> nested mapping starting after the dash.
+                lines[cursor.index - 1] = { text: rest, line: current.line, indent: indent + 2 };
+                cursor.index -= 1;
+                items.push(parseBlock(lines, cursor, indent + 2));
+                continue;
+            }
+            items.push(parseScalar(rest, current.line, indent + 3));
+        }
+        return { kind: "seq", items, line: first.line, column: indent + 1 };
+    }
+    const entries = [];
+    while (cursor.index < lines.length) {
+        const current = lines[cursor.index];
+        if (current.indent < indent)
+            break;
+        if (current.indent > indent)
+            throw new YamlSyntaxError(current.line, current.indent + 1, "inconsistent mapping key indentation");
+        if (current.text === "-" || current.text.startsWith("- "))
+            throw new YamlSyntaxError(current.line, current.indent + 1, "sequence item inside a mapping (check the dash indentation)");
+        const colonOffset = current.text.indexOf(":");
+        const { key, rest } = splitKey(current.text, current.line, current.indent + 1);
+        const valueColumn = current.indent + 1 + (colonOffset >= 0 ? colonOffset + 2 : current.text.length + 1);
+        cursor.index += 1;
+        if (rest.length === 0) {
+            if (cursor.index < lines.length && lines[cursor.index].indent > indent) {
+                entries.push({ key, keyLine: current.line, keyColumn: current.indent + 1, value: parseBlock(lines, cursor, lines[cursor.index].indent) });
+            }
+            else {
+                entries.push({ key, keyLine: current.line, keyColumn: current.indent + 1, value: { kind: "scalar", value: null, line: current.line, column: valueColumn } });
+            }
+            continue;
+        }
+        entries.push({ key, keyLine: current.line, keyColumn: current.indent + 1, value: parseScalar(rest, current.line, valueColumn) });
+    }
+    if (entries.length === 0)
+        throw new YamlSyntaxError(first.line, indent + 1, "empty mapping block");
+    return { kind: "map", entries, line: first.line, column: indent + 1 };
+}
+/** Parse an intent YAML document into a located node tree. */
+export function parseYaml(text) {
+    const lines = logicalLines(text);
+    if (lines.length === 0)
+        throw new YamlSyntaxError(1, 1, "intent file is empty");
+    const rootIndent = lines[0].indent;
+    for (const line of lines.slice(1)) {
+        if (line.indent < rootIndent)
+            throw new YamlSyntaxError(line.line, line.indent + 1, "top-level indentation must be consistent (the root block starts at one column)");
+    }
+    const cursor = { index: 0 };
+    const node = parseBlock(lines, cursor, rootIndent);
+    if (cursor.index < lines.length) {
+        const leftover = lines[cursor.index];
+        throw new YamlSyntaxError(leftover.line, leftover.indent + 1, `unexpected content after the document ("${leftover.text}")`);
+    }
+    return node;
+}
+/** Plain JS value of a located tree (positions dropped). */
+export function toPlain(node) {
+    if (node.kind === "scalar")
+        return node.value;
+    if (node.kind === "seq")
+        return node.items.map(toPlain);
+    return Object.fromEntries(node.entries.map((entry) => [entry.key, toPlain(entry.value)]));
+}
+/** Walk a "a.b[0].c"-style path to its node, for error reporting. */
+export function nodeAt(node, path) {
+    const segments = path.split(".");
+    let current = node;
+    for (const rawSegment of segments) {
+        if (current === undefined)
+            return undefined;
+        const arrayMatch = /^([^\[]+)\[(\d+)\]$/.exec(rawSegment);
+        if (arrayMatch) {
+            if (current.kind !== "map")
+                return undefined;
+            const entry = current.entries.find((candidate) => candidate.key === arrayMatch[1]);
+            if (entry === undefined || entry.value.kind !== "seq")
+                return undefined;
+            current = entry.value.items[Number(arrayMatch[2])];
+            continue;
+        }
+        if (current.kind !== "map")
+            return undefined;
+        const entry = current.entries.find((candidate) => candidate.key === rawSegment);
+        if (entry === undefined)
+            return undefined;
+        current = entry.value;
+    }
+    return current;
+}
+/** Locate a mapping KEY (not its value) — the pointer shown for key-level errors. */
+export function locateKey(node, path) {
+    const lastSlash = path.lastIndexOf(".");
+    const parent = lastSlash === -1 ? node : nodeAt(node, path.slice(0, lastSlash));
+    const key = lastSlash === -1 ? path : path.slice(lastSlash + 1);
+    if (parent === undefined || parent.kind !== "map")
+        return undefined;
+    const entry = parent.entries.find((candidate) => candidate.key === key);
+    if (entry === undefined)
+        return undefined;
+    return { line: entry.keyLine, column: entry.keyColumn };
+}
+//# sourceMappingURL=yaml.js.map

package/dist/json-column.js

@@ -0,0 +1,68 @@
+/**
+ * Ticket 52 — one explicit home for "a platform JSON column may arrive as a
+ * string (or an object)" decoding/encoding. Previously every lane carried a
+ * local copy with subtly different behaviour; the deliberate differences are
+ * now NAMED POLICIES chosen at each call site:
+ *
+ * - `JSON_COLUMN_PASSTHROUGH` — non-strings pass through untouched
+ *   (undefined stays undefined); unparseable strings return verbatim.
+ *   (datarule options, field.list readback)
+ * - `JSON_COLUMN_NULL_COALESCE` — non-strings null-coalesce (undefined →
+ *   null); blank/unparseable strings return verbatim ("" stays "").
+ *   (businessrule node/route/schedulerSetting, b2 configJson/parameter faces,
+ *   rule-support parameter faces, list-view condition options)
+ * - `{ invalid: "throw" }` — a corrupt column is a hard error
+ *   (field.update merge base reads the stored options strictly).
+ *
+ * Blank strings ("", "   ") are not valid JSON, so they always take the
+ * `invalid` branch; at every previous site that meant passthrough.
+ */
+export const JSON_COLUMN_PASSTHROUGH = { nonString: "passthrough", invalid: "passthrough" };
+export const JSON_COLUMN_NULL_COALESCE = { nonString: "null", invalid: "passthrough" };
+export function decodeJsonColumn(value, policy) {
+    if (typeof value !== "string")
+        return policy.nonString === "null" ? value ?? null : value;
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        if (policy.invalid === "throw")
+            throw error;
+        return value;
+    }
+}
+/** Wire encode: a string is sent as-is, anything else is JSON-stringified. */
+export function encodeJsonColumn(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+/**
+ * Decode an options face that may be a JSON string or already an object into
+ * a plain record (or undefined). Policies preserve the previous per-site
+ * semantics: relation options accept strings/objects/arrays loosely; the
+ * FORMULA formulaConfig validator only accepts strings that parse to a
+ * non-array object; field.update/form-scaffold strict reads throw on corrupt
+ * strings.
+ */
+export function decodeJsonObjectColumn(value, policy) {
+    const asRecord = (parsed) => {
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        if (Array.isArray(parsed))
+            return policy.array === "reject" ? undefined : parsed;
+        return parsed;
+    };
+    if (typeof value === "string") {
+        try {
+            return asRecord(JSON.parse(value));
+        }
+        catch (error) {
+            if (policy.invalid === "throw")
+                throw error;
+            return undefined;
+        }
+    }
+    if (policy.object === "reject")
+        return undefined;
+    return asRecord(value);
+}
+//# sourceMappingURL=json-column.js.map

package/dist/lanes/app-contract.js

@@ -0,0 +1,95 @@
+import { assertDescriptionCarries, assertLaneContract, behaviorBinding, CONTRACT_FAMILY, CONTRACT_REFERENCE_VERSION } from "./contract-support.js";
+import { LANES } from "./lane-ids.js";
+/**
+ * app-management wire facts (live-proven). The default-group resolution, the
+ * publish boundary, and the whole-record update quirk are the single source
+ * for the handler descriptions and the coverage declarations.
+ */
+export const APP_WIRE = Object.freeze({
+    createBody: "apppackage/create body {groupId, code, name, name_i18n}",
+    createReadiness: "app.create refuses missing/unresolved application groups before create wire (zero wire); readback carries selectedGroup, postconditions, publishBoundary, recovery",
+    defaultGroupResolution: "explicit groupId > configured app's groupId (auto-configured-app-group) > tenant first named non-fallback group (auto-first-group, warning:resolved-to-first-group); a fallback-group landing (code=all) warns resolved-to-fallback-group; portalHidden:true",
+    publishBoundary: "app publish is out of boundary; the operator must publish in the designer and verify the group, otherwise the portal is invisible",
+    updateBody: "apppackage/update submits the whole record by id; an explicit groupId takes effect, an omitted groupId is forced back to the default group, and enabled!==true clears workflow favorites — so app.update re-reads the record and only changes groupId while preserving the stored enabled value",
+    deleteBody: "apppackage/delete?appCode=; APP_PACKAGE_HAS_NODE refuses when the app still has non-folder nodes (delete models first)",
+    deletePoll: "apppackage/list polls to exact absence",
+});
+export const APP_LANE_CONTRACT = Object.freeze({
+    lane: LANES.app,
+    family: CONTRACT_FAMILY,
+    referenceVersion: CONTRACT_REFERENCE_VERSION,
+    endpoints: Object.freeze({
+        list: "applicationList",
+        groupList: "applicationGroupList",
+        get: "applicationGet",
+        create: "applicationCreate",
+        update: "applicationUpdate",
+        delete: "applicationDelete",
+    }),
+    wire: Object.freeze({
+        createBody: APP_WIRE.createBody,
+        createReadiness: APP_WIRE.createReadiness,
+        defaultGroupResolution: APP_WIRE.defaultGroupResolution,
+        publishBoundary: APP_WIRE.publishBoundary,
+        updateBody: APP_WIRE.updateBody,
+        deleteBody: APP_WIRE.deleteBody,
+        deletePoll: APP_WIRE.deletePoll,
+    }),
+    wireBindings: Object.freeze({
+        createBody: Object.freeze([behaviorBinding("test/app-management.test.ts#app.create plans, executes under approval, and reads back presence", assertAppContract)]),
+        createReadiness: Object.freeze([behaviorBinding("test/ticket-04-environment-readiness.test.ts#app.create refuses missing or unresolved groups before the create wire", assertAppContract)]),
+        defaultGroupResolution: Object.freeze([behaviorBinding("test/app-management.test.ts#app.create default group follows the configured application's group", assertAppContract)]),
+        publishBoundary: Object.freeze([behaviorBinding("test/app-management.test.ts#app.create falls back to the first group with a warning", assertAppContract)]),
+        updateBody: Object.freeze([behaviorBinding("test/app-management.test.ts#app.update preserves false enabled and does not invent i18n fields", assertAppContract)]),
+        deleteBody: Object.freeze([behaviorBinding("test/app-management.test.ts#app.delete removes the app via the admin delete endpoint", assertAppContract)]),
+        deletePoll: Object.freeze([behaviorBinding("test/app-management.test.ts#app.delete of an absent app is a no-op with proven absence", assertAppContract)]),
+    }),
+    evidence: Object.freeze([
+        "packages/omc-cli/test/app-management.test.ts",
+        "packages/omc-cli/src/lanes/app.ts",
+        ".scratch/omc-app-management/issues/01-app-create-default-group-unreachable.md",
+        ".scratch/omc-app-management/issues/04-app-move-group-capability.md",
+    ]),
+    tools: Object.freeze({
+        "app.list": Object.freeze({
+            scope: "app package list",
+            description: "列出应用（apppackage/list）及其所属分组；用于跨应用解析，以及 app.create/app.delete 前后的读回。",
+        }),
+        "app.create": Object.freeze({
+            scope: "app package create",
+            description: "创建一个设计时应用（apppackage/create）。groupId 可选，缺省解析配置应用所在分组（操作者必然可见）；配置应用不存在时回退租户第一个具名非兜底分组（auto-first-group，warning:resolved-to-first-group）。落到兜底分组 code=all 时读回带 warning:resolved-to-fallback-group; portalHidden:true。创建后以 apppackage/list 读回存在性。应用发布属边界外：建成后需人工在设计器发布并核对该分组，否则门户不可见。",
+        }),
+        "app.update": Object.freeze({
+            scope: "app package update",
+            description: "更新一个应用（apppackage/update，管理员面；8.6.26 源码证据：AppPackageController.update → AppIntegrationFacadeImpl.updateAppPackage，按记录 id 整体提交，显式 groupId 生效，缺省 groupId 会被强制回默认分组，enabled 非 true 会清 workflow 收藏——故本工具读回记录后仅改 groupId 并原样保留 enabled）。当前仅支持改 `groupId`（应用迁移分组的补救路径），不隐式补写 i18nMessage，name 等其他字段以读回值原样回传。以 apppackage/list 读回分组变更。",
+        }),
+        "app.delete": Object.freeze({
+            scope: "app package delete absence",
+            description: "删除一个应用（apppackage/delete?appCode=，管理员面：级联删除其下模型数据）。要求应用下无非目录节点，否则以 APP_PACKAGE_HAS_NODE 拒绝——先删模型再删应用。以 apppackage/list 轮询读回精确缺席。必须显式传 `code`，没有默认应用，避免误删。",
+        }),
+    }),
+});
+export function assertAppContract() {
+    assertLaneContract(APP_LANE_CONTRACT);
+    if (!APP_WIRE.defaultGroupResolution.includes("resolved-to-first-group"))
+        throw new Error("app contract pins the first-group fallback warning token");
+    assertDescriptionCarries(APP_LANE_CONTRACT, "app.list", ["apppackage/list", "跨应用"]);
+    assertDescriptionCarries(APP_LANE_CONTRACT, "app.create", ["apppackage/create", "resolved-to-first-group", "边界外"]);
+    if (!APP_WIRE.createReadiness.includes("zero"))
+        throw new Error("app contract must pin the zero-wire prerequisite refusal");
+    assertDescriptionCarries(APP_LANE_CONTRACT, "app.update", ["apppackage/update", "groupId", "enabled", "原样保留", "AppPackageController.update"]);
+    assertDescriptionCarries(APP_LANE_CONTRACT, "app.delete", ["apppackage/delete", "APP_PACKAGE_HAS_NODE", "缺席"]);
+    if (!APP_WIRE.createBody.includes("apppackage/create"))
+        throw new Error("app contract must pin the create endpoint");
+    if (!APP_WIRE.defaultGroupResolution.includes("auto-first-group"))
+        throw new Error("app contract must pin the first-group fallback");
+    if (!APP_WIRE.publishBoundary.includes("out of boundary"))
+        throw new Error("app contract must pin the publish boundary");
+    if (!APP_WIRE.updateBody.includes("only changes groupId"))
+        throw new Error("app contract must pin the whole-record update quirk");
+    if (!APP_WIRE.deleteBody.includes("APP_PACKAGE_HAS_NODE"))
+        throw new Error("app contract must pin the delete precondition");
+    if (!APP_WIRE.deletePoll.includes("exact absence"))
+        throw new Error("app contract must pin the delete absence poll");
+}
+//# sourceMappingURL=app-contract.js.map

package/dist/lanes/app-coverage.js

@@ -0,0 +1,16 @@
+import { claim, declareLaneCoverage } from "./coverage-declaration.js";
+import { APP_LANE_CONTRACT } from "./app-contract.js";
+const T = APP_LANE_CONTRACT.tools;
+export const APP_COVERAGE = declareLaneCoverage(APP_LANE_CONTRACT.lane, [
+    {
+        capability: "Application package (app) lifecycle: list, create, update (group move), admin delete",
+        evidence: ["packages/omc-cli/test/app-management.test.ts", "packages/omc-cli/src/lanes/app.ts"],
+        tools: [
+            claim("app.list", T["app.list"].scope),
+            claim("app.create", T["app.create"].scope),
+            claim("app.update", T["app.update"].scope),
+            claim("app.delete", T["app.delete"].scope),
+        ],
+    },
+]);
+//# sourceMappingURL=app-coverage.js.map