@fission-ai/openspec 0.17.2 → 0.18.0

package/dist/core/archive.d.ts

@@ -6,11 +6,6 @@ export declare class ArchiveCommand {
         validate?: boolean;
     }): Promise<void>;
     private selectChange;
-    private checkIncompleteTasks;
-    private findSpecUpdates;
-    private buildUpdatedSpec;
-    private writeUpdatedSpec;
-    private buildSpecSkeleton;
     private getArchiveDate;
 }
 //# sourceMappingURL=archive.d.ts.map

package/dist/core/archive.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { getTaskProgressForChange, formatTaskStatus } from '../utils/task-progress.js';
 import { Validator } from './validation/validator.js';
 import chalk from 'chalk';
-import { extractRequirementsSection, parseDeltaSpec, normalizeRequirementName, } from './parsers/requirement-blocks.js';
+import { findSpecUpdates, buildUpdatedSpec, writeUpdatedSpec, } from './specs-apply.js';
 export class ArchiveCommand {
     async execute(changeName, options = {}) {
         const targetPath = '.';
@@ -148,7 +148,7 @@ export class ArchiveCommand {
         }
         else {
             // Find specs to update
-            const specUpdates = await this.findSpecUpdates(changeDir, mainSpecsDir);
+            const specUpdates = await findSpecUpdates(changeDir, mainSpecsDir);
             if (specUpdates.length > 0) {
                 console.log('\nSpecs to update:');
                 for (const update of specUpdates) {
@@ -172,7 +172,7 @@ export class ArchiveCommand {
                     const prepared = [];
                     try {
                         for (const update of specUpdates) {
-                            const built = await this.buildUpdatedSpec(update, changeName);
+                            const built = await buildUpdatedSpec(update, changeName);
                             prepared.push({ update, rebuilt: built.rebuilt, counts: built.counts });
                         }
                     }
@@ -199,7 +199,7 @@ export class ArchiveCommand {
                                 return;
                             }
                         }
-                        await this.writeUpdatedSpec(p.update, p.rebuilt, p.counts);
+                        await writeUpdatedSpec(p.update, p.rebuilt, p.counts);
                         totals.added += p.counts.added;
                         totals.modified += p.counts.modified;
                         totals.removed += p.counts.removed;
@@ -272,259 +272,6 @@ export class ArchiveCommand {
             return null;
         }
     }
-    // Deprecated: replaced by shared task-progress utilities
-    async checkIncompleteTasks(_tasksPath) {
-        return 0;
-    }
-    async findSpecUpdates(changeDir, mainSpecsDir) {
-        const updates = [];
-        const changeSpecsDir = path.join(changeDir, 'specs');
-        try {
-            const entries = await fs.readdir(changeSpecsDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    const specFile = path.join(changeSpecsDir, entry.name, 'spec.md');
-                    const targetFile = path.join(mainSpecsDir, entry.name, 'spec.md');
-                    try {
-                        await fs.access(specFile);
-                        // Check if target exists
-                        let exists = false;
-                        try {
-                            await fs.access(targetFile);
-                            exists = true;
-                        }
-                        catch {
-                            exists = false;
-                        }
-                        updates.push({
-                            source: specFile,
-                            target: targetFile,
-                            exists
-                        });
-                    }
-                    catch {
-                        // Source spec doesn't exist, skip
-                    }
-                }
-            }
-        }
-        catch {
-            // No specs directory in change
-        }
-        return updates;
-    }
-    async buildUpdatedSpec(update, changeName) {
-        // Read change spec content (delta-format expected)
-        const changeContent = await fs.readFile(update.source, 'utf-8');
-        // Parse deltas from the change spec file
-        const plan = parseDeltaSpec(changeContent);
-        const specName = path.basename(path.dirname(update.target));
-        // Pre-validate duplicates within sections
-        const addedNames = new Set();
-        for (const add of plan.added) {
-            const name = normalizeRequirementName(add.name);
-            if (addedNames.has(name)) {
-                throw new Error(`${specName} validation failed - duplicate requirement in ADDED for header "### Requirement: ${add.name}"`);
-            }
-            addedNames.add(name);
-        }
-        const modifiedNames = new Set();
-        for (const mod of plan.modified) {
-            const name = normalizeRequirementName(mod.name);
-            if (modifiedNames.has(name)) {
-                throw new Error(`${specName} validation failed - duplicate requirement in MODIFIED for header "### Requirement: ${mod.name}"`);
-            }
-            modifiedNames.add(name);
-        }
-        const removedNamesSet = new Set();
-        for (const rem of plan.removed) {
-            const name = normalizeRequirementName(rem);
-            if (removedNamesSet.has(name)) {
-                throw new Error(`${specName} validation failed - duplicate requirement in REMOVED for header "### Requirement: ${rem}"`);
-            }
-            removedNamesSet.add(name);
-        }
-        const renamedFromSet = new Set();
-        const renamedToSet = new Set();
-        for (const { from, to } of plan.renamed) {
-            const fromNorm = normalizeRequirementName(from);
-            const toNorm = normalizeRequirementName(to);
-            if (renamedFromSet.has(fromNorm)) {
-                throw new Error(`${specName} validation failed - duplicate FROM in RENAMED for header "### Requirement: ${from}"`);
-            }
-            if (renamedToSet.has(toNorm)) {
-                throw new Error(`${specName} validation failed - duplicate TO in RENAMED for header "### Requirement: ${to}"`);
-            }
-            renamedFromSet.add(fromNorm);
-            renamedToSet.add(toNorm);
-        }
-        // Pre-validate cross-section conflicts
-        const conflicts = [];
-        for (const n of modifiedNames) {
-            if (removedNamesSet.has(n))
-                conflicts.push({ name: n, a: 'MODIFIED', b: 'REMOVED' });
-            if (addedNames.has(n))
-                conflicts.push({ name: n, a: 'MODIFIED', b: 'ADDED' });
-        }
-        for (const n of addedNames) {
-            if (removedNamesSet.has(n))
-                conflicts.push({ name: n, a: 'ADDED', b: 'REMOVED' });
-        }
-        // Renamed interplay: MODIFIED must reference the NEW header, not FROM
-        for (const { from, to } of plan.renamed) {
-            const fromNorm = normalizeRequirementName(from);
-            const toNorm = normalizeRequirementName(to);
-            if (modifiedNames.has(fromNorm)) {
-                throw new Error(`${specName} validation failed - when a rename exists, MODIFIED must reference the NEW header "### Requirement: ${to}"`);
-            }
-            // Detect ADDED colliding with a RENAMED TO
-            if (addedNames.has(toNorm)) {
-                throw new Error(`${specName} validation failed - RENAMED TO header collides with ADDED for "### Requirement: ${to}"`);
-            }
-        }
-        if (conflicts.length > 0) {
-            const c = conflicts[0];
-            throw new Error(`${specName} validation failed - requirement present in multiple sections (${c.a} and ${c.b}) for header "### Requirement: ${c.name}"`);
-        }
-        const hasAnyDelta = (plan.added.length + plan.modified.length + plan.removed.length + plan.renamed.length) > 0;
-        if (!hasAnyDelta) {
-            throw new Error(`Delta parsing found no operations for ${path.basename(path.dirname(update.source))}. ` +
-                `Provide ADDED/MODIFIED/REMOVED/RENAMED sections in change spec.`);
-        }
-        // Load or create base target content
-        let targetContent;
-        try {
-            targetContent = await fs.readFile(update.target, 'utf-8');
-        }
-        catch {
-            // Target spec does not exist; only ADDED operations are permitted
-            if (plan.modified.length > 0 || plan.removed.length > 0 || plan.renamed.length > 0) {
-                throw new Error(`${specName}: target spec does not exist; only ADDED requirements are allowed for new specs.`);
-            }
-            targetContent = this.buildSpecSkeleton(specName, changeName);
-        }
-        // Extract requirements section and build name->block map
-        const parts = extractRequirementsSection(targetContent);
-        const nameToBlock = new Map();
-        for (const block of parts.bodyBlocks) {
-            nameToBlock.set(normalizeRequirementName(block.name), block);
-        }
-        // Apply operations in order: RENAMED → REMOVED → MODIFIED → ADDED
-        // RENAMED
-        for (const r of plan.renamed) {
-            const from = normalizeRequirementName(r.from);
-            const to = normalizeRequirementName(r.to);
-            if (!nameToBlock.has(from)) {
-                throw new Error(`${specName} RENAMED failed for header "### Requirement: ${r.from}" - source not found`);
-            }
-            if (nameToBlock.has(to)) {
-                throw new Error(`${specName} RENAMED failed for header "### Requirement: ${r.to}" - target already exists`);
-            }
-            const block = nameToBlock.get(from);
-            const newHeader = `### Requirement: ${to}`;
-            const rawLines = block.raw.split('\n');
-            rawLines[0] = newHeader;
-            const renamedBlock = {
-                headerLine: newHeader,
-                name: to,
-                raw: rawLines.join('\n'),
-            };
-            nameToBlock.delete(from);
-            nameToBlock.set(to, renamedBlock);
-        }
-        // REMOVED
-        for (const name of plan.removed) {
-            const key = normalizeRequirementName(name);
-            if (!nameToBlock.has(key)) {
-                throw new Error(`${specName} REMOVED failed for header "### Requirement: ${name}" - not found`);
-            }
-            nameToBlock.delete(key);
-        }
-        // MODIFIED
-        for (const mod of plan.modified) {
-            const key = normalizeRequirementName(mod.name);
-            if (!nameToBlock.has(key)) {
-                throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - not found`);
-            }
-            // Replace block with provided raw (ensure header line matches key)
-            const modHeaderMatch = mod.raw.split('\n')[0].match(/^###\s*Requirement:\s*(.+)\s*$/);
-            if (!modHeaderMatch || normalizeRequirementName(modHeaderMatch[1]) !== key) {
-                throw new Error(`${specName} MODIFIED failed for header "### Requirement: ${mod.name}" - header mismatch in content`);
-            }
-            nameToBlock.set(key, mod);
-        }
-        // ADDED
-        for (const add of plan.added) {
-            const key = normalizeRequirementName(add.name);
-            if (nameToBlock.has(key)) {
-                throw new Error(`${specName} ADDED failed for header "### Requirement: ${add.name}" - already exists`);
-            }
-            nameToBlock.set(key, add);
-        }
-        // Duplicates within resulting map are implicitly prevented by key uniqueness.
-        // Recompose requirements section preserving original ordering where possible
-        const keptOrder = [];
-        const seen = new Set();
-        for (const block of parts.bodyBlocks) {
-            const key = normalizeRequirementName(block.name);
-            const replacement = nameToBlock.get(key);
-            if (replacement) {
-                keptOrder.push(replacement);
-                seen.add(key);
-            }
-        }
-        // Append any newly added that were not in original order
-        for (const [key, block] of nameToBlock.entries()) {
-            if (!seen.has(key)) {
-                keptOrder.push(block);
-            }
-        }
-        const reqBody = [
-            parts.preamble && parts.preamble.trim() ? parts.preamble.trimEnd() : ''
-        ]
-            .filter(Boolean)
-            .concat(keptOrder.map(b => b.raw))
-            .join('\n\n')
-            .trimEnd();
-        const rebuilt = [
-            parts.before.trimEnd(),
-            parts.headerLine,
-            reqBody,
-            parts.after
-        ]
-            .filter((s, idx) => !(idx === 0 && s === ''))
-            .join('\n')
-            .replace(/\n{3,}/g, '\n\n');
-        return {
-            rebuilt,
-            counts: {
-                added: plan.added.length,
-                modified: plan.modified.length,
-                removed: plan.removed.length,
-                renamed: plan.renamed.length,
-            }
-        };
-    }
-    async writeUpdatedSpec(update, rebuilt, counts) {
-        // Create target directory if needed
-        const targetDir = path.dirname(update.target);
-        await fs.mkdir(targetDir, { recursive: true });
-        await fs.writeFile(update.target, rebuilt);
-        const specName = path.basename(path.dirname(update.target));
-        console.log(`Applying changes to openspec/specs/${specName}/spec.md:`);
-        if (counts.added)
-            console.log(`  + ${counts.added} added`);
-        if (counts.modified)
-            console.log(`  ~ ${counts.modified} modified`);
-        if (counts.removed)
-            console.log(`  - ${counts.removed} removed`);
-        if (counts.renamed)
-            console.log(`  → ${counts.renamed} renamed`);
-    }
-    buildSpecSkeleton(specFolderName, changeName) {
-        const titleBase = specFolderName;
-        return `# ${titleBase} Specification\n\n## Purpose\nTBD - created by archiving change ${changeName}. Update Purpose after archive.\n\n## Requirements\n`;
-    }
     getArchiveDate() {
         // Returns date in YYYY-MM-DD format
         return new Date().toISOString().split('T')[0];

package/dist/core/artifact-graph/graph.d.ts

@@ -0,0 +1,56 @@
+import type { Artifact, SchemaYaml, CompletedSet, BlockedArtifacts } from './types.js';
+/**
+ * Represents an artifact dependency graph.
+ * Provides methods for querying build order, ready artifacts, and completion status.
+ */
+export declare class ArtifactGraph {
+    private artifacts;
+    private schema;
+    private constructor();
+    /**
+     * Creates an ArtifactGraph from a YAML file path.
+     */
+    static fromYaml(filePath: string): ArtifactGraph;
+    /**
+     * Creates an ArtifactGraph from YAML content string.
+     */
+    static fromYamlContent(yamlContent: string): ArtifactGraph;
+    /**
+     * Creates an ArtifactGraph from a pre-validated schema object.
+     */
+    static fromSchema(schema: SchemaYaml): ArtifactGraph;
+    /**
+     * Gets a single artifact by ID.
+     */
+    getArtifact(id: string): Artifact | undefined;
+    /**
+     * Gets all artifacts in the graph.
+     */
+    getAllArtifacts(): Artifact[];
+    /**
+     * Gets the schema name.
+     */
+    getName(): string;
+    /**
+     * Gets the schema version.
+     */
+    getVersion(): number;
+    /**
+     * Computes the topological build order using Kahn's algorithm.
+     * Returns artifact IDs in the order they should be built.
+     */
+    getBuildOrder(): string[];
+    /**
+     * Gets artifacts that are ready to be created (all dependencies completed).
+     */
+    getNextArtifacts(completed: CompletedSet): string[];
+    /**
+     * Checks if all artifacts in the graph are completed.
+     */
+    isComplete(completed: CompletedSet): boolean;
+    /**
+     * Gets blocked artifacts and their unmet dependencies.
+     */
+    getBlocked(completed: CompletedSet): BlockedArtifacts;
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/core/artifact-graph/graph.js

@@ -0,0 +1,141 @@
+import { loadSchema, parseSchema } from './schema.js';
+/**
+ * Represents an artifact dependency graph.
+ * Provides methods for querying build order, ready artifacts, and completion status.
+ */
+export class ArtifactGraph {
+    artifacts;
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+        this.artifacts = new Map(schema.artifacts.map(a => [a.id, a]));
+    }
+    /**
+     * Creates an ArtifactGraph from a YAML file path.
+     */
+    static fromYaml(filePath) {
+        const schema = loadSchema(filePath);
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Creates an ArtifactGraph from YAML content string.
+     */
+    static fromYamlContent(yamlContent) {
+        const schema = parseSchema(yamlContent);
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Creates an ArtifactGraph from a pre-validated schema object.
+     */
+    static fromSchema(schema) {
+        return new ArtifactGraph(schema);
+    }
+    /**
+     * Gets a single artifact by ID.
+     */
+    getArtifact(id) {
+        return this.artifacts.get(id);
+    }
+    /**
+     * Gets all artifacts in the graph.
+     */
+    getAllArtifacts() {
+        return Array.from(this.artifacts.values());
+    }
+    /**
+     * Gets the schema name.
+     */
+    getName() {
+        return this.schema.name;
+    }
+    /**
+     * Gets the schema version.
+     */
+    getVersion() {
+        return this.schema.version;
+    }
+    /**
+     * Computes the topological build order using Kahn's algorithm.
+     * Returns artifact IDs in the order they should be built.
+     */
+    getBuildOrder() {
+        const inDegree = new Map();
+        const dependents = new Map();
+        // Initialize all artifacts
+        for (const artifact of this.artifacts.values()) {
+            inDegree.set(artifact.id, artifact.requires.length);
+            dependents.set(artifact.id, []);
+        }
+        // Build reverse adjacency (who depends on whom)
+        for (const artifact of this.artifacts.values()) {
+            for (const req of artifact.requires) {
+                dependents.get(req).push(artifact.id);
+            }
+        }
+        // Start with roots (in-degree 0), sorted for determinism
+        const queue = [...this.artifacts.keys()]
+            .filter(id => inDegree.get(id) === 0)
+            .sort();
+        const result = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            result.push(current);
+            // Collect newly ready artifacts, then sort before adding
+            const newlyReady = [];
+            for (const dep of dependents.get(current)) {
+                const newDegree = inDegree.get(dep) - 1;
+                inDegree.set(dep, newDegree);
+                if (newDegree === 0) {
+                    newlyReady.push(dep);
+                }
+            }
+            queue.push(...newlyReady.sort());
+        }
+        return result;
+    }
+    /**
+     * Gets artifacts that are ready to be created (all dependencies completed).
+     */
+    getNextArtifacts(completed) {
+        const ready = [];
+        for (const artifact of this.artifacts.values()) {
+            if (completed.has(artifact.id)) {
+                continue; // Already completed
+            }
+            const allDepsCompleted = artifact.requires.every(req => completed.has(req));
+            if (allDepsCompleted) {
+                ready.push(artifact.id);
+            }
+        }
+        // Sort for deterministic ordering
+        return ready.sort();
+    }
+    /**
+     * Checks if all artifacts in the graph are completed.
+     */
+    isComplete(completed) {
+        for (const artifact of this.artifacts.values()) {
+            if (!completed.has(artifact.id)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Gets blocked artifacts and their unmet dependencies.
+     */
+    getBlocked(completed) {
+        const blocked = {};
+        for (const artifact of this.artifacts.values()) {
+            if (completed.has(artifact.id)) {
+                continue; // Already completed
+            }
+            const unmetDeps = artifact.requires.filter(req => !completed.has(req));
+            if (unmetDeps.length > 0) {
+                blocked[artifact.id] = unmetDeps.sort();
+            }
+        }
+        return blocked;
+    }
+}
+//# sourceMappingURL=graph.js.map

package/dist/core/artifact-graph/index.d.ts

@@ -0,0 +1,7 @@
+export { ArtifactSchema, SchemaYamlSchema, type Artifact, type SchemaYaml, type CompletedSet, type BlockedArtifacts, } from './types.js';
+export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
+export { ArtifactGraph } from './graph.js';
+export { detectCompleted } from './state.js';
+export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, type SchemaInfo, } from './resolver.js';
+export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, type ChangeContext, type ArtifactInstructions, type DependencyInfo, type ArtifactStatus, type ChangeStatus, } from './instruction-loader.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/artifact-graph/index.js

@@ -0,0 +1,13 @@
+// Types
+export { ArtifactSchema, SchemaYamlSchema, } from './types.js';
+// Schema loading and validation
+export { loadSchema, parseSchema, SchemaValidationError } from './schema.js';
+// Graph operations
+export { ArtifactGraph } from './graph.js';
+// State detection
+export { detectCompleted } from './state.js';
+// Schema resolution
+export { resolveSchema, listSchemas, listSchemasWithInfo, getSchemaDir, getPackageSchemasDir, getUserSchemasDir, SchemaLoadError, } from './resolver.js';
+// Instruction loading
+export { loadTemplate, loadChangeContext, generateInstructions, formatChangeStatus, TemplateLoadError, } from './instruction-loader.js';
+//# sourceMappingURL=index.js.map

package/dist/core/artifact-graph/instruction-loader.d.ts

@@ -0,0 +1,130 @@
+import { ArtifactGraph } from './graph.js';
+import type { CompletedSet } from './types.js';
+/**
+ * Error thrown when loading a template fails.
+ */
+export declare class TemplateLoadError extends Error {
+    readonly templatePath: string;
+    constructor(message: string, templatePath: string);
+}
+/**
+ * Change context containing graph, completion state, and metadata.
+ */
+export interface ChangeContext {
+    /** The artifact dependency graph */
+    graph: ArtifactGraph;
+    /** Set of completed artifact IDs */
+    completed: CompletedSet;
+    /** Schema name being used */
+    schemaName: string;
+    /** Change name */
+    changeName: string;
+    /** Path to the change directory */
+    changeDir: string;
+}
+/**
+ * Enriched instructions for creating an artifact.
+ */
+export interface ArtifactInstructions {
+    /** Change name */
+    changeName: string;
+    /** Artifact ID */
+    artifactId: string;
+    /** Schema name */
+    schemaName: string;
+    /** Full path to change directory */
+    changeDir: string;
+    /** Output path pattern (e.g., "proposal.md") */
+    outputPath: string;
+    /** Artifact description */
+    description: string;
+    /** Guidance on how to create this artifact (from schema instruction field) */
+    instruction: string | undefined;
+    /** Template content (structure to follow) */
+    template: string;
+    /** Dependencies with completion status and paths */
+    dependencies: DependencyInfo[];
+    /** Artifacts that become available after completing this one */
+    unlocks: string[];
+}
+/**
+ * Dependency information including path and description.
+ */
+export interface DependencyInfo {
+    /** Artifact ID */
+    id: string;
+    /** Whether the dependency is completed */
+    done: boolean;
+    /** Relative output path of the dependency (e.g., "proposal.md") */
+    path: string;
+    /** Description of the dependency artifact */
+    description: string;
+}
+/**
+ * Status of a single artifact in the workflow.
+ */
+export interface ArtifactStatus {
+    /** Artifact ID */
+    id: string;
+    /** Output path pattern */
+    outputPath: string;
+    /** Status: done, ready, or blocked */
+    status: 'done' | 'ready' | 'blocked';
+    /** Missing dependencies (only for blocked) */
+    missingDeps?: string[];
+}
+/**
+ * Formatted change status.
+ */
+export interface ChangeStatus {
+    /** Change name */
+    changeName: string;
+    /** Schema name */
+    schemaName: string;
+    /** Whether all artifacts are complete */
+    isComplete: boolean;
+    /** Artifact IDs required before apply phase (from schema's apply.requires) */
+    applyRequires: string[];
+    /** Status of each artifact */
+    artifacts: ArtifactStatus[];
+}
+/**
+ * Loads a template from a schema's templates directory.
+ *
+ * @param schemaName - Schema name (e.g., "spec-driven")
+ * @param templatePath - Relative path within the templates directory (e.g., "proposal.md")
+ * @returns The template content
+ * @throws TemplateLoadError if the template cannot be loaded
+ */
+export declare function loadTemplate(schemaName: string, templatePath: string): string;
+/**
+ * Loads change context combining graph and completion state.
+ *
+ * Schema resolution order:
+ * 1. Explicit schemaName parameter (if provided)
+ * 2. Schema from .openspec.yaml metadata (if exists in change directory)
+ * 3. Default 'spec-driven'
+ *
+ * @param projectRoot - Project root directory
+ * @param changeName - Change name
+ * @param schemaName - Optional schema name override. If not provided, auto-detected from metadata.
+ * @returns Change context with graph, completed set, and metadata
+ */
+export declare function loadChangeContext(projectRoot: string, changeName: string, schemaName?: string): ChangeContext;
+/**
+ * Generates enriched instructions for creating an artifact.
+ *
+ * @param context - Change context
+ * @param artifactId - Artifact ID to generate instructions for
+ * @returns Enriched artifact instructions
+ * @throws Error if artifact not found
+ */
+export declare function generateInstructions(context: ChangeContext, artifactId: string): ArtifactInstructions;
+/**
+ * Formats the status of all artifacts in a change.
+ *
+ * @param context - Change context
+ * @returns Formatted change status
+ */
+export declare function formatChangeStatus(context: ChangeContext): ChangeStatus;
+//# sourceMappingURL=instruction-loader.d.ts.map