@fitlab-ai/agent-infra 0.9.15 → 0.10.0

package/dist/lib/sandbox/workspace-identity.js

@@ -98,7 +98,23 @@ export function resolveSandboxCleanupTarget(requestedRef, repoRoot, options = {}
         throw new Error(`Invalid task short id '${requestedRef}': task short ids must use bare digits`);
     }
     if (TASK_ID_RE.test(requestedRef)) {
-        const task = resolveTaskWorkspace(requestedRef, repoRoot);
+        let task;
+        try {
+            task = resolveTaskWorkspace(requestedRef, repoRoot);
+        }
+        catch (error) {
+            if (!(error instanceof Error && error.message === `Task not found: ${requestedRef}`))
+                throw error;
+            const branch = options.resolveMissingTask?.(requestedRef);
+            if (!branch)
+                throw error;
+            return {
+                requestedRef,
+                branch,
+                workspace: { mode: 'task-bound', taskId: requestedRef },
+                taskState: 'unknown'
+            };
+        }
         if (!options.allowProtected && (task.state === 'blocked' || task.state === 'archive')) {
             throw new Error(`SANDBOX_CLEANUP_STATE_UNSUPPORTED: task ${requestedRef} is ${task.state}`);
         }

package/dist/lib/task/artifact-command.js

@@ -1,24 +1,21 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { readStableFileSync } from '../host-control/secure-fs.js';
 import { resolveArtifactContext, hasOpenArtifactRound } from './artifact-lifecycle.js';
 import { parseArtifactName } from './artifact-name.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { finalizeLocalArtifact } from './local-artifact-finalization.js';
-import { applyArtifactRepair, initializeArtifactSkeleton, inspectArtifactStructure } from './artifact-operations.js';
+import { initializeArtifactSkeleton } from './artifact-operations.js';
 /** One option contract for the CLI and trusted projection executor. */
 export function parseArtifactCommand(args) {
     const [taskRef, operation] = args;
-    if (!taskRef || !['inspect', 'init', 'repair', 'finalize-local'].includes(operation ?? '')) {
+    if (!taskRef || !['inspect', 'init', 'finalize-local'].includes(operation ?? '')) {
         throw new Error('task ref and a supported artifact operation are required');
     }
     const fields = {};
     const allowed = {
         inspect: ['--family'],
         init: ['--family', '--artifact', '--locale'],
-        repair: ['--family', '--artifact', '--expected-sha256', '--expected-semantic-digest'],
-        'finalize-local': ['--family', '--artifact']
+        'finalize-local': ['--family', '--artifact', '--recovery-id']
     }[operation];
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
@@ -38,18 +35,14 @@ export function parseArtifactCommand(args) {
     const locale = fields['--locale'];
     if (locale !== undefined && locale !== 'zh-CN' && locale !== 'en')
         throw new Error("option '--locale' must be 'zh-CN' or 'en'");
-    if (operation === 'repair' && !['--expected-sha256', '--expected-semantic-digest'].every((flag) => /^[a-f0-9]{64}$/u.test(fields[flag] ?? ''))) {
-        throw new Error('repair requires lowercase 64-character digests');
-    }
     return {
         taskRef, operation: operation, family: fields['--family'],
-        artifact: fields['--artifact'] ?? '', locale,
-        expectedSha256: fields['--expected-sha256'] ?? '', expectedSemanticDigest: fields['--expected-semantic-digest'] ?? ''
+        artifact: fields['--artifact'] ?? '', locale, recoveryId: fields['--recovery-id']
     };
 }
 /** Resolve authoritative task metadata separately from a trusted candidate directory. */
 export function executeArtifactCommand(command, options = {}) {
-    const { taskRef, operation, family, artifact, locale, expectedSha256, expectedSemanticDigest } = command;
+    const { taskRef, operation, family, artifact, locale, recoveryId } = command;
     const fail = (code, message) => ({ status: 'failed', changed: false, error: { code, message } });
     if (operation === 'inspect') {
         const result = resolveArtifactContext(taskRef, family, { repoRoot: options.repoRoot });
@@ -78,24 +71,9 @@ export function executeArtifactCommand(command, options = {}) {
         }
         return { ...initializeArtifactSkeleton({ ...input, ...(locale ? { locale } : {}) }), ...identity };
     }
-    if (operation === 'repair') {
-        let content;
-        try {
-            content = readStableFileSync(path.join(taskDir, artifact), { maxBytes: 1024 * 1024 }).bytes.toString('utf8');
-        }
-        catch (error) {
-            return fail('ARTIFACT_REPAIR_TARGET_INVALID', String(error));
-        }
-        const inspection = inspectArtifactStructure(content, schema);
-        if (!inspection.repair) {
-            return { ...fail('ARTIFACT_REPAIR_UNSAFE', inspection.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ') || 'no deterministic structural repair is available'),
-                artifact, family, diagnostics: inspection.diagnostics };
-        }
-        return { ...applyArtifactRepair({ ...input, expectedSha256, expectedSemanticDigest, operation: inspection.repair }), ...identity };
-    }
     if (family !== 'analysis' && family !== 'plan' && family !== 'code') {
         return fail('ARTIFACT_PAYLOAD_INVALID', "finalize-local only supports 'analysis', 'plan', and 'code'");
     }
-    return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot }) };
+    return { ...finalizeLocalArtifact({ taskRef, family, artifact, repoRoot: resolved.repoRoot, recoveryId }) };
 }
 //# sourceMappingURL=artifact-command.js.map

package/dist/lib/task/artifact-operations.js

@@ -1,12 +1,9 @@
 import fs from 'node:fs';
-import { parseArtifactName } from './artifact-name.js';
 import path from 'node:path';
 import { createHash } from 'node:crypto';
 import { readStableFileSync } from '../host-control/secure-fs.js';
+import { parseArtifactName } from './artifact-name.js';
 import { scanVisibleMarkdown } from './markdown.js';
-import { hasOpenArtifactRound } from './artifact-lifecycle.js';
-import { readArtifactRepairIntent } from './artifact-repair-intent.js';
-import { resolveTaskRef } from './resolve-ref.js';
 import { getArtifactSchema, renderArtifactSkeleton } from './artifact-schema.js';
 import { withTaskExecutionLock } from './task-execution-lock.js';
 function sha256Content(content) {
@@ -60,70 +57,26 @@ function stripHtmlComments(content) {
     }
     return result;
 }
-function diagnostic(code, message, sectionId, line, repairable = false, operation) {
-    return {
-        code, message, sectionId, line, repairable,
-        ...(operation ? { operation } : {})
-    };
+function diagnostic(code, message, sectionId, line) {
+    return { code, message, sectionId, line };
 }
 function sectionHeadings(schema, section) {
     return [section.headings.zh, section.headings.en];
 }
-function createHeadingRepair(content, section, heading) {
-    const to = heading.text.slice(0, -1);
-    return {
-        kind: 'replace-line',
-        sectionId: section.id,
-        line: lineNumber(content, heading.start),
-        from: heading.text,
-        to,
-        start: heading.start,
-        end: heading.end
-    };
-}
-function createSectionInsertionRepair(content, section, marker, locale) {
-    return {
-        kind: 'insert-section',
-        sectionId: section.id,
-        line: marker.line,
-        from: '',
-        to: `## ${section.headings[locale === 'en' ? 'en' : 'zh']}\n`,
-        start: marker.start,
-        end: marker.start
-    };
-}
-function applyRepairOperation(content, operation) {
-    if (operation.start < 0 || operation.end < operation.start || operation.end > content.length)
-        return null;
-    if (operation.kind === 'insert-section') {
-        if (operation.from !== '' || operation.start !== operation.end || !operation.to)
-            return null;
-        return `${content.slice(0, operation.start)}${operation.to}${content.slice(operation.end)}`;
-    }
-    const raw = content.slice(operation.start, operation.end);
-    const offset = raw.indexOf(operation.from);
-    if (!operation.from || offset < 0 || raw.indexOf(operation.from, offset + operation.from.length) >= 0)
-        return null;
-    return `${content.slice(0, operation.start)}${raw.slice(0, offset)}${operation.to}${raw.slice(offset + operation.from.length)}${content.slice(operation.end)}`;
-}
-function canonicalContent(content, operation = null) {
+function canonicalContent(content) {
     let normalized = content;
-    if (operation) {
-        normalized = applyRepairOperation(normalized, operation) ?? normalized;
-    }
     normalized = normalized.replace(/\r\n/g, '\n');
     normalized = normalized.replace(/^<!--\s*artifact-context:[^\n]+-->\s*\n?/gm, '');
     normalized = normalized.replace(/^\s*<!--\s*artifact-section:[^\n]+-->\s*\n?/gm, '');
     normalized = normalized.replace(/^\s*<!--\s*artifact-slot:empty\s*-->\s*\n?/gm, '');
     return normalized;
 }
-function canonicalSemanticDigest(content, operation = null) {
-    return sha256Content(canonicalContent(content, operation));
+function canonicalSemanticDigest(content) {
+    return sha256Content(canonicalContent(content));
 }
 function inspectArtifactStructure(content, schema) {
     const diagnostics = [];
     const scanned = scanVisibleMarkdown(content);
-    const repairCandidates = [];
     if (!content.trim())
         diagnostics.push(diagnostic('ARTIFACT_EMPTY', 'artifact is empty', null, null));
     if (scanned.hasUnclosedFence)
@@ -133,22 +86,19 @@ function inspectArtifactStructure(content, schema) {
         const aliases = sectionHeadings(schema, section);
         const exact = scanned.headings.filter((heading) => heading.level === 2 && aliases.includes(heading.text));
         const punctuated = scanned.headings.filter((heading) => heading.level === 2 && aliases.some((alias) => heading.text === `${alias}:` || heading.text === `${alias}：`));
-        headingsBySection.set(section.id, exact.length === 0 && punctuated.length === 1 ? punctuated : exact);
+        headingsBySection.set(section.id, exact.length > 0 ? exact : punctuated);
         if (exact.length > 1 || punctuated.length > 0 && exact.length > 0 || punctuated.length > 1) {
             const first = exact[1] ?? punctuated[0] ?? exact[0];
             diagnostics.push(diagnostic('ARTIFACT_DUPLICATE_SECTION', `required section '${aliases[0]}' is duplicated or has an ambiguous punctuation variant`, section.id, first ? lineNumber(content, first.start) : null));
         }
         else if (exact.length === 0 && punctuated.length === 1) {
-            repairCandidates.push(createHeadingRepair(content, section, punctuated[0]));
+            diagnostics.push(diagnostic('ARTIFACT_HEADING_TRAILING_PUNCTUATION', `visible required H2 '${punctuated[0].text}' has trailing punctuation`, section.id, lineNumber(content, punctuated[0].start)));
         }
         else if (exact.length === 0) {
             diagnostics.push(diagnostic('ARTIFACT_MISSING_SECTION', `required section '${aliases[0]}' is missing`, section.id, null));
         }
     }
     const markers = markerEntries(content, scanned);
-    const englishHeadings = scanned.headings.filter((heading) => heading.level === 2 && schema.sections.some((section) => section.headings.en === heading.text)).length;
-    const chineseHeadings = scanned.headings.filter((heading) => heading.level === 2 && schema.sections.some((section) => section.headings.zh === heading.text)).length;
-    const locale = englishHeadings > chineseHeadings ? 'en' : 'zh-CN';
     for (const section of schema.sections) {
         const matches = markers.filter((entry) => entry.marker === section.marker);
         if (matches.length === 0) {
@@ -174,10 +124,7 @@ function inspectArtifactStructure(content, schema) {
         if (marker && !heading && marker.standalone) {
             const nextHeading = scanned.headings.find((candidate) => candidate.start > marker.start && candidate.level <= 2);
             const body = stripHtmlComments(content.slice(marker.end, nextHeading?.start ?? content.length)).trim();
-            if (body && repairCandidates.length === 0) {
-                repairCandidates.push(createSectionInsertionRepair(content, section, marker, locale));
-            }
-            else if (!body) {
+            if (!body) {
                 diagnostics.push(diagnostic('ARTIFACT_EMPTY_SECTION', `section '${section.headings.zh}' has no semantic body`, section.id, marker.line));
             }
         }
@@ -187,17 +134,6 @@ function inspectArtifactStructure(content, schema) {
             diagnostics.push(diagnostic('ARTIFACT_MARKER_MISMATCH', `unknown section marker '${marker.marker}'`, null, marker.line));
         }
     }
-    for (const candidate of repairCandidates) {
-        if (candidate.kind === 'replace-line') {
-            diagnostics.push(diagnostic('ARTIFACT_HEADING_TRAILING_PUNCTUATION', `visible required H2 '${candidate.from}' may be normalized to '${candidate.to}'`, candidate.sectionId, candidate.line, true, candidate));
-            continue;
-        }
-        const missing = diagnostics.findIndex((item) => item.code === 'ARTIFACT_MISSING_SECTION' && item.sectionId === candidate.sectionId);
-        if (missing >= 0) {
-            const section = schema.sections.find((item) => item.id === candidate.sectionId);
-            diagnostics.splice(missing, 1, diagnostic('ARTIFACT_MISSING_SECTION', `required section '${section.headings.zh}' is missing and can be inserted at its unique marker`, candidate.sectionId, candidate.line, true, candidate));
-        }
-    }
     const orderedHeadings = schema.sections.flatMap((section) => {
         const heading = headingsBySection.get(section.id)?.[0];
         return heading ? [{ section, start: heading.start }] : [];
@@ -212,14 +148,11 @@ function inspectArtifactStructure(content, schema) {
     if (orderedMarkers.some((item, index) => index > 0 && item.start <= orderedMarkers[index - 1].start)) {
         diagnostics.push(diagnostic('ARTIFACT_SECTION_ORDER_INVALID', 'section markers are not in schema order', null, null));
     }
-    const repair = repairCandidates.length === 1 && (diagnostics.length === 0 ||
-        (diagnostics.length === 1 && diagnostics[0]?.operation?.kind === repairCandidates[0]?.kind)) ? repairCandidates[0] : null;
     return {
         ok: diagnostics.length === 0,
         family: schema.family,
-        semanticDigest: canonicalSemanticDigest(content, repair),
-        diagnostics,
-        repair
+        semanticDigest: canonicalSemanticDigest(content),
+        diagnostics
     };
 }
 function inspectArtifactPatterns(content, schema) {
@@ -230,25 +163,22 @@ function inspectArtifactPatterns(content, schema) {
         ok: diagnostics.length === 0,
         family: schema.family,
         semanticDigest: canonicalSemanticDigest(content),
-        diagnostics,
-        repair: null
+        diagnostics
     };
 }
 function inspectArtifactContract(content, schema) {
     const structure = inspectArtifactStructure(content, schema);
     const patterns = inspectArtifactPatterns(content, schema);
     const diagnostics = [...structure.diagnostics, ...patterns.diagnostics];
-    const repair = patterns.diagnostics.length === 0 ? structure.repair : null;
     return {
         ok: diagnostics.length === 0,
         family: schema.family,
-        semanticDigest: canonicalSemanticDigest(content, repair),
-        diagnostics,
-        repair
+        semanticDigest: canonicalSemanticDigest(content),
+        diagnostics
     };
 }
 function resultFailure(code, message) {
-    return { status: 'failed', changed: false, artifactSha256: null, semanticDigest: null, operation: null, error: { code, message } };
+    return { status: 'failed', changed: false, artifactSha256: null, semanticDigest: null, error: { code, message } };
 }
 function resultNoOp(content) {
     return {
@@ -256,156 +186,13 @@ function resultNoOp(content) {
         changed: false,
         artifactSha256: sha256Content(content),
         semanticDigest: canonicalSemanticDigest(content),
-        operation: null,
         error: null
     };
 }
-function validateRepairContext(request, content) {
-    const round = artifactRound(request.family, request.artifact);
-    if (round === null)
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: 'artifact round is not canonical' };
-    const contextPattern = /^<!--\s*artifact-context:([^:\s]+):([^:\s]+):(\d+)\s*-->\s*$/;
-    const contexts = scanVisibleMarkdown(content).lines
-        .map((line) => line.text.trim().match(contextPattern))
-        .filter((match) => match !== null);
-    if (contexts.length !== 1
-        || contexts[0][1] !== request.taskId
-        || contexts[0][2] !== request.family
-        || Number(contexts[0][3]) !== round) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: 'artifact context marker does not match the requested task, family, and round' };
-    }
-    let taskContent;
-    const resolved = resolveTaskRef(request.taskId, { repoRoot: request.repoRoot });
-    if (!resolved.ok)
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: resolved.message };
-    try {
-        taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
-    }
-    catch (error) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: `cannot read task lifecycle context: ${String(error)}` };
-    }
-    if (!hasOpenArtifactRound(taskContent, request.family, round)) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_CONTEXT_INVALID', message: `artifact '${request.artifact}' does not have exactly one matching open started lifecycle event` };
-    }
-    let intent;
-    try {
-        intent = readArtifactRepairIntent(request.repoRoot, request.taskId, request.family, request.artifact);
-    }
-    catch (error) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_PROVENANCE_INVALID', message: String(error) };
-    }
-    if (!intent || intent.state !== 'awaiting-repair') {
-        return { ok: false, code: 'ARTIFACT_REPAIR_PROVENANCE_INVALID', message: 'artifact has no awaiting-repair finalization provenance' };
-    }
-    if (intent.artifactSha256 !== request.expectedSha256 || intent.semanticDigest !== request.expectedSemanticDigest) {
-        return { ok: false, code: 'ARTIFACT_REPAIR_PROVENANCE_INVALID', message: 'repair request does not match the current finalization provenance' };
-    }
-    return { ok: true };
-}
 function artifactRound(family, artifact) {
     const identity = parseArtifactName(artifact);
     return identity?.family === family ? identity.round : null;
 }
-function validateTarget(taskDir, family, artifact) {
-    if (path.basename(artifact) !== artifact || artifactRound(family, artifact) === null || !artifact.endsWith('.md'))
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', 'artifact must be a canonical top-level Markdown file');
-    if (!/^TASK-\d{8}-\d{6}$/.test(path.basename(path.resolve(taskDir))))
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', 'target directory is not a task directory');
-    const target = path.join(taskDir, artifact);
-    if (path.dirname(path.resolve(target)) !== path.resolve(taskDir))
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', 'artifact must be inside the current task directory');
-    let stat;
-    try {
-        stat = fs.lstatSync(target);
-    }
-    catch (error) {
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', `artifact cannot be read: ${String(error)}`);
-    }
-    if (stat.isSymbolicLink() || !stat.isFile())
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', 'artifact is not a regular file');
-    try {
-        fs.accessSync(target, fs.constants.R_OK | fs.constants.W_OK);
-    }
-    catch (error) {
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', `artifact is not readable and writable: ${String(error)}`);
-    }
-    return { path: target };
-}
-function applyRepairUnlocked(request) {
-    const schema = getArtifactSchema(request.family);
-    if (!schema)
-        return resultFailure('ARTIFACT_FAMILY_UNKNOWN', `unknown artifact family '${request.family}'`);
-    const target = validateTarget(request.taskDir, request.family, request.artifact);
-    if ('status' in target)
-        return target;
-    let content;
-    try {
-        content = readStableFileSync(target.path, { maxBytes: 1024 * 1024 }).bytes.toString('utf8');
-    }
-    catch (error) {
-        return resultFailure('ARTIFACT_REPAIR_TARGET_INVALID', String(error));
-    }
-    const actualSha256 = sha256Content(content);
-    if (actualSha256 !== request.expectedSha256)
-        return resultFailure('ARTIFACT_REPAIR_BASELINE_MISMATCH', 'artifact SHA-256 does not match the expected repair baseline');
-    const context = validateRepairContext(request, content);
-    if (!context.ok)
-        return resultFailure(context.code, context.message);
-    const inspection = inspectArtifactStructure(content, schema);
-    if (!inspection.repair || inspection.diagnostics.length !== 1) {
-        return resultFailure('ARTIFACT_REPAIR_UNSAFE', inspection.diagnostics.map((item) => `${item.code}: ${item.message}`).join('; ') || 'no deterministic structural repair is available');
-    }
-    if (inspection.repair.kind !== request.operation.kind
-        || inspection.repair.sectionId !== request.operation.sectionId
-        || inspection.repair.from !== request.operation.from
-        || inspection.repair.to !== request.operation.to
-        || inspection.repair.start !== request.operation.start
-        || inspection.repair.end !== request.operation.end) {
-        return resultFailure('ARTIFACT_REPAIR_OPERATION_MISMATCH', 'repair operation does not match the current artifact structure');
-    }
-    if (inspection.semanticDigest !== request.expectedSemanticDigest)
-        return resultFailure('ARTIFACT_REPAIR_BASELINE_MISMATCH', 'artifact semantic digest does not match the expected repair baseline');
-    const transformed = applyRepairOperation(content, inspection.repair);
-    if (transformed === null)
-        return resultFailure('ARTIFACT_REPAIR_OPERATION_MISMATCH', 'repair operation does not match the current artifact bytes');
-    if (transformed === content)
-        return resultFailure('ARTIFACT_REPAIR_NO_PROGRESS', 'repair operation produced no byte change');
-    const tempPath = path.join(request.taskDir, `.${request.artifact}.repair-${process.pid}-${Date.now()}.tmp`);
-    let mode = 0o600;
-    try {
-        mode = fs.statSync(target.path).mode & 0o777;
-        fs.writeFileSync(tempPath, transformed, { encoding: 'utf8', mode, flag: 'wx' });
-        const currentStat = fs.lstatSync(target.path);
-        if (currentStat.isSymbolicLink() || !currentStat.isFile() || readStableFileSync(target.path, { maxBytes: 1024 * 1024 }).sha256 !== actualSha256) {
-            fs.unlinkSync(tempPath);
-            return resultFailure('ARTIFACT_REPAIR_CONFLICT', 'artifact changed or was replaced during repair');
-        }
-        fs.renameSync(tempPath, target.path);
-    }
-    catch (error) {
-        try {
-            fs.unlinkSync(tempPath);
-        }
-        catch { /* preserve primary error */ }
-        return resultFailure('ARTIFACT_REPAIR_WRITE_FAILED', String(error));
-    }
-    return {
-        status: 'applied',
-        changed: true,
-        artifactSha256: sha256Content(transformed),
-        semanticDigest: canonicalSemanticDigest(transformed),
-        operation: inspection.repair,
-        error: null
-    };
-}
-function applyArtifactRepair(request) {
-    try {
-        return withTaskExecutionLock(request.repoRoot, request.taskId, 'task-artifact.repair', () => applyRepairUnlocked(request));
-    }
-    catch (error) {
-        return resultFailure('ARTIFACT_REPAIR_LOCK_FAILED', String(error));
-    }
-}
 function initializeArtifactSkeleton(request) {
     const schema = getArtifactSchema(request.family);
     if (!schema)
@@ -461,7 +248,6 @@ function initializeArtifactSkeleton(request) {
                 changed: true,
                 artifactSha256: sha256Content(content),
                 semanticDigest: canonicalSemanticDigest(content),
-                operation: null,
                 error: null
             };
         });
@@ -470,5 +256,5 @@ function initializeArtifactSkeleton(request) {
         return resultFailure('ARTIFACT_INIT_LOCK_FAILED', String(error));
     }
 }
-export { applyArtifactRepair, canonicalSemanticDigest, initializeArtifactSkeleton, inspectArtifactContract, inspectArtifactPatterns, inspectArtifactStructure, sha256Content };
+export { canonicalSemanticDigest, initializeArtifactSkeleton, inspectArtifactContract, inspectArtifactPatterns, inspectArtifactStructure, sha256Content };
 //# sourceMappingURL=artifact-operations.js.map