@shrkcrft/cli 0.1.0-alpha.1

package/dist/asset-preview/apply-knowledge-stale-fix.js

@@ -0,0 +1,344 @@
+/**
+ * Knowledge-stale apply splicer.
+ *
+ * Removes a single stale / missing reference from a knowledge entry's
+ * `references[]` array. Pure-text mutation; preview-first under the
+ * hood (callers compute the patch with `write: false` for every target
+ * before writing).
+ *
+ * Supports both "drop the reference" and "rename in place" paths;
+ * the latter activates when the caller supplies a `renameTo` payload.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { findEntryRange, removeArrayEntries } from "./entry-mutator.js";
+function escapesCwd(cwd, absPath) {
+    const rel = nodePath.relative(cwd, absPath);
+    return rel.startsWith('..') || nodePath.isAbsolute(rel);
+}
+function buildUnifiedDiff(rel, a, b) {
+    const aLines = a.split('\n');
+    const bLines = b.split('\n');
+    let prefix = 0;
+    while (prefix < aLines.length && prefix < bLines.length && aLines[prefix] === bLines[prefix]) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    while (suffix < aLines.length - prefix &&
+        suffix < bLines.length - prefix &&
+        aLines[aLines.length - 1 - suffix] === bLines[bLines.length - 1 - suffix]) {
+        suffix += 1;
+    }
+    const aMid = aLines.slice(prefix, aLines.length - suffix);
+    const bMid = bLines.slice(prefix, bLines.length - suffix);
+    const head = `--- ${rel}\n+++ ${rel}\n@@ -${prefix + 1},${aMid.length} +${prefix + 1},${bMid.length} @@\n`;
+    return (head +
+        aMid.map((l) => `-${l}`).join('\n') +
+        (aMid.length ? '\n' : '') +
+        bMid.map((l) => `+${l}`).join('\n'));
+}
+/**
+ * Match a `references[]` element string against an `IKnowledgeReference`
+ * by `kind` and every identifying field the reference carries (`id`,
+ * `path`, `symbol`). When the reference has multiple identifying fields
+ * (e.g. symbol refs typically have both `symbol` and `path`), the
+ * element must match ALL of them — otherwise we risk matching the
+ * wrong neighbor.
+ */
+function elementMatchesReference(element, ref) {
+    const escapedKind = ref.kind.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const kindRe = new RegExp(`\\bkind\\s*:\\s*['"]${escapedKind}['"]`);
+    if (!kindRe.test(element))
+        return false;
+    const id = ref.id;
+    const path = ref.path;
+    const symbol = ref.symbol;
+    // Each present identifying field must match.
+    const checks = [];
+    if (id !== undefined)
+        checks.push({ key: 'id', value: id });
+    if (path !== undefined)
+        checks.push({ key: 'path', value: path });
+    if (symbol !== undefined)
+        checks.push({ key: 'symbol', value: symbol });
+    if (checks.length === 0)
+        return false;
+    for (const c of checks) {
+        const escapedValue = c.value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const re = new RegExp(`\\b${c.key}\\s*:\\s*['"]${escapedValue}['"]`);
+        if (!re.test(element))
+            return false;
+    }
+    return true;
+}
+/**
+ * Rewrite a matching reference element's identifying field
+ * in place. Returns the new body and whether the rewrite landed.
+ *
+ * The rewrite is intentionally narrow: it operates on the single
+ * element string identified by `elementMatchesReference` and swaps
+ * the relevant field's quoted value. The rest of the entry (kind,
+ * other fields, surrounding entries) is untouched.
+ */
+function renameReferenceInElement(element, ref, renameTo) {
+    let next = element;
+    let renamed = false;
+    const rewrite = (key, oldValue, newValue) => {
+        if (!newValue || !oldValue)
+            return;
+        const escapedKey = key;
+        const escapedOld = oldValue.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const re = new RegExp(`(\\b${escapedKey}\\s*:\\s*['"])${escapedOld}(['"])`);
+        if (re.test(next)) {
+            next = next.replace(re, (_m, head, tail) => head + newValue + tail);
+            renamed = true;
+        }
+    };
+    const id = ref.id;
+    const path = ref.path;
+    const symbol = ref.symbol;
+    if (renameTo.path !== undefined)
+        rewrite('path', path, renameTo.path);
+    if (renameTo.id !== undefined)
+        rewrite('id', id, renameTo.id);
+    if (renameTo.symbol !== undefined)
+        rewrite('symbol', symbol, renameTo.symbol);
+    return { next, renamed };
+}
+/**
+ * Replace the matching reference element inside an entry's
+ * `references[]` array. The bracket-balanced scan is intentional —
+ * the same parsing rules as `removeArrayEntries` so we don't break
+ * on nested objects or strings containing commas.
+ */
+function replaceReferenceElement(body, open, close, ref, renameTo) {
+    // Find `references: [` inside [open..close].
+    const slice = body.slice(open, close + 1);
+    const fm = /\breferences\s*:\s*\[/.exec(slice);
+    if (!fm)
+        return { body, renamed: false };
+    const arrayOpenIdx = open + fm.index + fm[0].length - 1;
+    // Walk to matching `]` with string + bracket awareness.
+    let depth = 0;
+    let arrayCloseIdx = -1;
+    let inString = null;
+    let escape = false;
+    for (let i = arrayOpenIdx; i < body.length; i++) {
+        const c = body[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (inString) {
+            if (c === '\\') {
+                escape = true;
+                continue;
+            }
+            if (c === inString)
+                inString = null;
+            continue;
+        }
+        if (c === '"' || c === "'" || c === '`') {
+            inString = c;
+            continue;
+        }
+        if (c === '[' || c === '{' || c === '(')
+            depth++;
+        else if (c === ']' || c === '}' || c === ')') {
+            depth--;
+            if (depth === 0 && c === ']') {
+                arrayCloseIdx = i;
+                break;
+            }
+        }
+    }
+    if (arrayCloseIdx === -1)
+        return { body, renamed: false };
+    const inner = body.slice(arrayOpenIdx + 1, arrayCloseIdx);
+    // Split at top-level commas (lightweight inline implementation —
+    // keeps this module self-contained).
+    const parts = [];
+    {
+        let d = 0;
+        let s = null;
+        let e = false;
+        let start = 0;
+        for (let i = 0; i < inner.length; i++) {
+            const c = inner[i];
+            if (e) {
+                e = false;
+                continue;
+            }
+            if (s) {
+                if (c === '\\') {
+                    e = true;
+                    continue;
+                }
+                if (c === s)
+                    s = null;
+                continue;
+            }
+            if (c === '"' || c === "'" || c === '`') {
+                s = c;
+                continue;
+            }
+            if (c === '[' || c === '{' || c === '(')
+                d++;
+            else if (c === ']' || c === '}' || c === ')')
+                d--;
+            else if (c === ',' && d === 0) {
+                parts.push(inner.slice(start, i));
+                start = i + 1;
+            }
+        }
+        parts.push(inner.slice(start));
+    }
+    let renamed = false;
+    const next = [];
+    for (const p of parts) {
+        if (!renamed && elementMatchesReference(p, ref)) {
+            const r = renameReferenceInElement(p, ref, renameTo);
+            next.push(r.next);
+            renamed = r.renamed;
+        }
+        else {
+            next.push(p);
+        }
+    }
+    if (!renamed)
+        return { body, renamed: false };
+    const newInner = next.join(',');
+    return {
+        body: body.slice(0, arrayOpenIdx + 1) + newInner + body.slice(arrayCloseIdx),
+        renamed: true,
+    };
+}
+export function applyKnowledgeStaleFix(input) {
+    const cwd = nodePath.resolve(input.cwd);
+    const targetAbs = nodePath.resolve(cwd, input.targetPath);
+    if (escapesCwd(cwd, targetAbs)) {
+        return {
+            ok: false,
+            refusal: `Target path escapes the project root (cwd=${cwd}).`,
+            targetAbs,
+            entryId: input.entryId,
+            originalLength: 0,
+            nextLength: 0,
+            removedCount: 0,
+            mode: 'drop',
+            wrote: false,
+        };
+    }
+    if (!existsSync(targetAbs)) {
+        return {
+            ok: false,
+            refusal: `Target file not found: ${targetAbs}`,
+            targetAbs,
+            entryId: input.entryId,
+            originalLength: 0,
+            nextLength: 0,
+            removedCount: 0,
+            mode: 'drop',
+            wrote: false,
+        };
+    }
+    const body = readFileSync(targetAbs, 'utf8');
+    const range = findEntryRange(body, input.entryId);
+    if (!range) {
+        return {
+            ok: false,
+            refusal: `Entry "${input.entryId}" not found in ${nodePath.relative(cwd, targetAbs)}.`,
+            targetAbs,
+            entryId: input.entryId,
+            originalLength: body.length,
+            nextLength: body.length,
+            removedCount: 0,
+            mode: input.renameTo ? 'rename' : 'drop',
+            wrote: false,
+        };
+    }
+    // Rename path takes precedence when the caller supplied a
+    // replacement. Migration is strictly safer than drop.
+    if (input.renameTo) {
+        const renameResult = replaceReferenceElement(body, range.open, range.close, input.reference, input.renameTo);
+        if (!renameResult.renamed) {
+            return {
+                ok: false,
+                refusal: `Reference not found (or already at the new location) in entry "${input.entryId}".`,
+                targetAbs,
+                entryId: input.entryId,
+                originalLength: body.length,
+                nextLength: body.length,
+                removedCount: 0,
+                mode: 'rename',
+                wrote: false,
+            };
+        }
+        const nextBody = renameResult.body;
+        let wrote = false;
+        if (input.write && nextBody !== body) {
+            writeFileSync(targetAbs, nextBody, 'utf8');
+            wrote = true;
+        }
+        const rel = nodePath.relative(cwd, targetAbs) || nodePath.basename(targetAbs);
+        const diff = buildUnifiedDiff(rel, body, nextBody);
+        return {
+            ok: true,
+            targetAbs,
+            entryId: input.entryId,
+            originalLength: body.length,
+            nextLength: nextBody.length,
+            removedCount: 0,
+            mode: 'rename',
+            diff,
+            wrote,
+        };
+    }
+    // Default — drop the reference.
+    const result = removeArrayEntries(body, range, 'references', (element) => elementMatchesReference(element, input.reference));
+    if (!result) {
+        return {
+            ok: false,
+            refusal: `Entry "${input.entryId}" has no \`references\` array (or it's not a simple bracket form).`,
+            targetAbs,
+            entryId: input.entryId,
+            originalLength: body.length,
+            nextLength: body.length,
+            removedCount: 0,
+            mode: 'drop',
+            wrote: false,
+        };
+    }
+    if (result.removedCount === 0) {
+        return {
+            ok: false,
+            refusal: `Reference not found in entry "${input.entryId}" — already removed?`,
+            targetAbs,
+            entryId: input.entryId,
+            originalLength: body.length,
+            nextLength: body.length,
+            removedCount: 0,
+            mode: 'drop',
+            wrote: false,
+        };
+    }
+    const nextBody = result.body;
+    let wrote = false;
+    if (input.write && nextBody !== body) {
+        writeFileSync(targetAbs, nextBody, 'utf8');
+        wrote = true;
+    }
+    const rel = nodePath.relative(cwd, targetAbs) || nodePath.basename(targetAbs);
+    const diff = buildUnifiedDiff(rel, body, nextBody);
+    return {
+        ok: true,
+        targetAbs,
+        entryId: input.entryId,
+        originalLength: body.length,
+        nextLength: nextBody.length,
+        removedCount: result.removedCount,
+        mode: 'drop',
+        diff,
+        wrote,
+    };
+}

package/dist/asset-preview/apply-missing-barrel.d.ts

@@ -0,0 +1,15 @@
+export interface IMissingBarrelInput {
+    readonly cwd: string;
+    /** Project-relative path of the barrel to create. */
+    readonly barrelPath: string;
+    readonly write: boolean;
+}
+export interface IMissingBarrelResult {
+    readonly ok: boolean;
+    readonly refusal?: string;
+    readonly barrelAbs: string;
+    readonly bodyWritten?: string;
+    readonly wrote: boolean;
+}
+export declare function applyMissingBarrelFix(input: IMissingBarrelInput): IMissingBarrelResult;
+//# sourceMappingURL=apply-missing-barrel.d.ts.map

package/dist/asset-preview/apply-missing-barrel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-missing-barrel.d.ts","sourceRoot":"","sources":["../../src/asset-preview/apply-missing-barrel.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qDAAqD;IACrD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAYD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,mBAAmB,GACzB,oBAAoB,CAwCtB"}

package/dist/asset-preview/apply-missing-barrel.js

@@ -0,0 +1,65 @@
+/**
+ * Missing-barrel auto-create.
+ *
+ * When `templates drift` flags `missing-barrel` (template's `changes`
+ * list has an `export` op pointing at a non-existent index file), the
+ * fix is mechanical: create the missing file with a placeholder
+ * `export {};` body. The drift warning flips off because the file
+ * exists; the human still has to populate the re-exports.
+ *
+ * Hard rules:
+ *   - Refuses path-escape on the barrel target.
+ *   - Refuses pack targets (`node_modules/` or `dist/`).
+ *   - Idempotent — refuses if the file already exists.
+ *   - Creates parent directories as needed.
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+const PLACEHOLDER_BODY = '// AUTO-CREATED by `shrk fix --template-drift --apply`.\n' +
+    '// Populate with the expected re-exports before the next drift run.\n' +
+    'export {};\n';
+function escapesCwd(cwd, absPath) {
+    const rel = nodePath.relative(cwd, absPath);
+    return rel.startsWith('..') || nodePath.isAbsolute(rel);
+}
+export function applyMissingBarrelFix(input) {
+    const cwd = nodePath.resolve(input.cwd);
+    const barrelAbs = nodePath.resolve(cwd, input.barrelPath);
+    if (escapesCwd(cwd, barrelAbs)) {
+        return {
+            ok: false,
+            refusal: `Barrel path escapes the project root (cwd=${cwd}).`,
+            barrelAbs,
+            wrote: false,
+        };
+    }
+    const rel = nodePath.relative(cwd, barrelAbs);
+    if (rel.startsWith('node_modules' + nodePath.sep) || /\bdist\b/.test(rel)) {
+        return {
+            ok: false,
+            refusal: `Barrel target lives in a pack / build artifact (${rel}) — edit the source pack and re-sign instead.`,
+            barrelAbs,
+            wrote: false,
+        };
+    }
+    if (existsSync(barrelAbs)) {
+        return {
+            ok: false,
+            refusal: `Barrel already exists at ${rel} — nothing to create.`,
+            barrelAbs,
+            wrote: false,
+        };
+    }
+    let wrote = false;
+    if (input.write) {
+        mkdirSync(nodePath.dirname(barrelAbs), { recursive: true });
+        writeFileSync(barrelAbs, PLACEHOLDER_BODY, 'utf8');
+        wrote = true;
+    }
+    return {
+        ok: true,
+        barrelAbs,
+        bodyWritten: PLACEHOLDER_BODY,
+        wrote,
+    };
+}

package/dist/asset-preview/apply-template-drift-fix.d.ts

@@ -0,0 +1,21 @@
+export interface ITemplateDriftFixInput {
+    readonly cwd: string;
+    readonly targetPath: string;
+    readonly templateId: string;
+    /** Which `related[]` id to drop. */
+    readonly droppedRelatedId: string;
+    readonly write: boolean;
+}
+export interface ITemplateDriftFixResult {
+    readonly ok: boolean;
+    readonly refusal?: string;
+    readonly targetAbs: string;
+    readonly templateId: string;
+    readonly originalLength: number;
+    readonly nextLength: number;
+    readonly removedCount: number;
+    readonly diff?: string;
+    readonly wrote: boolean;
+}
+export declare function applyTemplateDriftFix(input: ITemplateDriftFixInput): ITemplateDriftFixResult;
+//# sourceMappingURL=apply-template-drift-fix.d.ts.map

package/dist/asset-preview/apply-template-drift-fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-template-drift-fix.d.ts","sourceRoot":"","sources":["../../src/asset-preview/apply-template-drift-fix.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oCAAoC;IACpC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAiCD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,sBAAsB,GAC5B,uBAAuB,CAoFzB"}

package/dist/asset-preview/apply-template-drift-fix.js

@@ -0,0 +1,125 @@
+/**
+ * Template-drift apply splicer.
+ *
+ * Scope: the `related-id-unresolved` code only.
+ * Most template-drift findings (`forbidden-legacy-path`,
+ * `missing-anchor`, `missing-produced-anchor`, `missing-barrel`, etc.)
+ * are template *body* issues — the `files()` / `changes()` resolver
+ * functions need to be edited. Those stay preview-only.
+ *
+ * For `related-id-unresolved`, the fix is mechanical: drop the
+ * unresolved id from the template's `related[]` array.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import * as nodePath from 'node:path';
+import { findEntryRange, removeStringFromArray } from "./entry-mutator.js";
+function escapesCwd(cwd, absPath) {
+    const rel = nodePath.relative(cwd, absPath);
+    return rel.startsWith('..') || nodePath.isAbsolute(rel);
+}
+function buildUnifiedDiff(rel, a, b) {
+    const aLines = a.split('\n');
+    const bLines = b.split('\n');
+    let prefix = 0;
+    while (prefix < aLines.length && prefix < bLines.length && aLines[prefix] === bLines[prefix]) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    while (suffix < aLines.length - prefix &&
+        suffix < bLines.length - prefix &&
+        aLines[aLines.length - 1 - suffix] === bLines[bLines.length - 1 - suffix]) {
+        suffix += 1;
+    }
+    const aMid = aLines.slice(prefix, aLines.length - suffix);
+    const bMid = bLines.slice(prefix, bLines.length - suffix);
+    const head = `--- ${rel}\n+++ ${rel}\n@@ -${prefix + 1},${aMid.length} +${prefix + 1},${bMid.length} @@\n`;
+    return (head +
+        aMid.map((l) => `-${l}`).join('\n') +
+        (aMid.length ? '\n' : '') +
+        bMid.map((l) => `+${l}`).join('\n'));
+}
+export function applyTemplateDriftFix(input) {
+    const cwd = nodePath.resolve(input.cwd);
+    const targetAbs = nodePath.resolve(cwd, input.targetPath);
+    if (escapesCwd(cwd, targetAbs)) {
+        return {
+            ok: false,
+            refusal: `Target path escapes the project root (cwd=${cwd}).`,
+            targetAbs,
+            templateId: input.templateId,
+            originalLength: 0,
+            nextLength: 0,
+            removedCount: 0,
+            wrote: false,
+        };
+    }
+    if (!existsSync(targetAbs)) {
+        return {
+            ok: false,
+            refusal: `Target file not found: ${targetAbs}`,
+            targetAbs,
+            templateId: input.templateId,
+            originalLength: 0,
+            nextLength: 0,
+            removedCount: 0,
+            wrote: false,
+        };
+    }
+    const body = readFileSync(targetAbs, 'utf8');
+    const range = findEntryRange(body, input.templateId);
+    if (!range) {
+        return {
+            ok: false,
+            refusal: `Template "${input.templateId}" not found in ${nodePath.relative(cwd, targetAbs)}.`,
+            targetAbs,
+            templateId: input.templateId,
+            originalLength: body.length,
+            nextLength: body.length,
+            removedCount: 0,
+            wrote: false,
+        };
+    }
+    const result = removeStringFromArray(body, range, 'related', input.droppedRelatedId);
+    if (!result) {
+        return {
+            ok: false,
+            refusal: `Template "${input.templateId}" has no \`related\` array (or it's not a simple bracket form).`,
+            targetAbs,
+            templateId: input.templateId,
+            originalLength: body.length,
+            nextLength: body.length,
+            removedCount: 0,
+            wrote: false,
+        };
+    }
+    if (result.removedCount === 0) {
+        return {
+            ok: false,
+            refusal: `Related id "${input.droppedRelatedId}" not present in "${input.templateId}" — already removed?`,
+            targetAbs,
+            templateId: input.templateId,
+            originalLength: body.length,
+            nextLength: body.length,
+            removedCount: 0,
+            wrote: false,
+        };
+    }
+    const nextBody = result.body;
+    let wrote = false;
+    if (input.write && nextBody !== body) {
+        writeFileSync(targetAbs, nextBody, 'utf8');
+        wrote = true;
+    }
+    const rel = nodePath.relative(cwd, targetAbs) || nodePath.basename(targetAbs);
+    const diff = buildUnifiedDiff(rel, body, nextBody);
+    return {
+        ok: true,
+        targetAbs,
+        templateId: input.templateId,
+        originalLength: body.length,
+        nextLength: nextBody.length,
+        removedCount: result.removedCount,
+        diff,
+        wrote,
+    };
+}

package/dist/asset-preview/apply-template-update.d.ts

@@ -0,0 +1,43 @@
+export type StringArrayOp = readonly string[] | {
+    readonly mode: 'add' | 'remove' | 'set';
+    readonly values: readonly string[];
+};
+export type MetadataArrayField = 'requiredAnchors' | 'requiredProfileIds' | 'forbiddenPathFragments' | 'requiredVerificationCommandIds';
+export type MetadataScalarField = 'priority' | 'maturity' | 'dryRunOnly' | 'requiresApproval';
+export interface ITemplateUpdateApplyInput {
+    readonly cwd: string;
+    readonly targetPath: string;
+    readonly templateId: string;
+    readonly fields: {
+        readonly name?: string;
+        readonly description?: string;
+        readonly tags?: StringArrayOp;
+        readonly scope?: StringArrayOp;
+        readonly appliesWhen?: StringArrayOp;
+        readonly related?: StringArrayOp;
+        readonly metadata?: {
+            readonly [K in MetadataScalarField]?: string | number | boolean;
+        } & {
+            readonly [K in MetadataArrayField]?: StringArrayOp;
+        };
+    };
+    readonly write: boolean;
+}
+export interface ITemplateUpdateApplyResult {
+    readonly ok: boolean;
+    readonly refusal?: string;
+    readonly targetAbs: string;
+    readonly templateId: string;
+    readonly originalLength: number;
+    readonly nextLength: number;
+    readonly fieldChanges: ReadonlyArray<{
+        field: string;
+        mode: 'replace' | 'insert';
+        /** For arrays, the merge mode the caller asked for. */
+        arrayMode?: 'add' | 'remove' | 'set';
+    }>;
+    readonly diff?: string;
+    readonly wrote: boolean;
+}
+export declare function applyTemplateUpdate(input: ITemplateUpdateApplyInput): ITemplateUpdateApplyResult;
+//# sourceMappingURL=apply-template-update.d.ts.map

package/dist/asset-preview/apply-template-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-template-update.d.ts","sourceRoot":"","sources":["../../src/asset-preview/apply-template-update.ts"],"names":[],"mappings":"AAmCA,MAAM,MAAM,aAAa,GACrB,SAAS,MAAM,EAAE,GACjB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,GAAG,QAAQ,GAAG,KAAK,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAEpF,MAAM,MAAM,kBAAkB,GAC1B,iBAAiB,GACjB,oBAAoB,GACpB,wBAAwB,GACxB,gCAAgC,CAAC;AAErC,MAAM,MAAM,mBAAmB,GAC3B,UAAU,GACV,UAAU,GACV,YAAY,GACZ,kBAAkB,CAAC;AAEvB,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC;QAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC;QAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,aAAa,CAAC;QACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;QACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE;YAClB,QAAQ,EAAE,CAAC,IAAI,mBAAmB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;SAChE,GAAG;YACF,QAAQ,EAAE,CAAC,IAAI,kBAAkB,CAAC,CAAC,EAAE,aAAa;SACnD,CAAC;KACH,CAAC;IACF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC;QACnC,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;QAC3B,uDAAuD;QACvD,SAAS,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,KAAK,CAAC;KACtC,CAAC,CAAC;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AA6DD,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,yBAAyB,GAC/B,0BAA0B,CAuL5B"}