@koan-labs/koan 0.2.0

package/dist/core/answers.js

@@ -0,0 +1,86 @@
+import { STATE_FILES } from "./constants.js";
+import { executeWritePlan } from "./documents.js";
+import { defaultProfile, loadProfile } from "./profile.js";
+import { findProjectRoot, loadProjectConfig } from "./project.js";
+import { getQuestion } from "./questions.js";
+import { AmbiguityAxisSchema, DEFAULT_CONVERGENCE_THRESHOLD } from "./schemas.js";
+import { ANSWERED_CLARITY, createInitialLedger, isConverged, loadLedger, selectMostUnclearAxis, unresolvedAxes, updateAxisScore } from "./scoring.js";
+import { loadSessionState } from "./session.js";
+const EVIDENCE_PREVIEW_LIMIT = 120;
+export async function recordAnswer(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const state = await loadSessionState(projectRoot);
+    if (!state)
+        throw new Error("No active Koan session. Run koan hello first.");
+    if (!state.activeGoalId || state.phase === "archived") {
+        throw new Error("No active goal. Run koan hello first.");
+    }
+    if (input.clarity !== undefined && (!Number.isFinite(input.clarity) || input.clarity < 0 || input.clarity > 1)) {
+        throw new Error("clarity must be a finite number between 0 and 1.");
+    }
+    const axis = AmbiguityAxisSchema.parse(input.axis);
+    const profile = (await loadProfile(input.homeDir)) ?? defaultProfile();
+    const isoDate = input.isoDate ?? new Date().toISOString();
+    const stored = await loadLedger(projectRoot);
+    const ledger = stored && stored.goalId === state.activeGoalId
+        ? stored
+        : createInitialLedger(state.activeGoalId, isoDate);
+    const trimmed = input.answer.trim();
+    const clarity = input.clarity ?? (trimmed.length > 0 ? ANSWERED_CLARITY : 0);
+    const updatedLedger = updateAxisScore(ledger, axis, clarity, Array.from(trimmed).slice(0, EVIDENCE_PREVIEW_LIMIT).join(""), isoDate);
+    const answer = {
+        questionId: axis,
+        axis,
+        question: input.question ?? getQuestion(axis, profile).userFacingQuestion,
+        answer: input.answer,
+        recordedAt: isoDate
+    };
+    const threshold = (await loadProjectConfig(projectRoot))?.settings.convergenceThreshold ?? DEFAULT_CONVERGENCE_THRESHOLD;
+    const converged = isConverged(updatedLedger, threshold);
+    const nextState = {
+        ...state,
+        answers: [...state.answers, answer],
+        lastQuestionId: axis,
+        phase: converged ? "ready" : "questioning",
+        updatedAt: isoDate
+    };
+    const source = input.source?.trim();
+    await executeWritePlan(projectRoot, {
+        description: "Persist recorded answer and ambiguity ledger",
+        operations: [
+            { type: "write", path: STATE_FILES.sessionState, content: `${JSON.stringify(nextState, null, 2)}\n` },
+            { type: "write", path: STATE_FILES.ambiguityLedger, content: `${JSON.stringify(updatedLedger, null, 2)}\n` }
+        ]
+    }, {
+        log: {
+            command: "koan answer",
+            summary: source ? `Recorded answer for ${axis} (source: ${source}).` : `Recorded answer for ${axis}.`
+        }
+    });
+    return {
+        projectRoot,
+        ledger: updatedLedger,
+        answer,
+        converged,
+        unresolved: unresolvedAxes(updatedLedger, threshold),
+        nextQuestion: converged ? null : getQuestion(selectMostUnclearAxis(updatedLedger), profile)
+    };
+}
+export async function acceptClarity(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const state = await loadSessionState(projectRoot);
+    if (!state)
+        throw new Error("No active Koan session. Run koan hello first.");
+    if (!state.activeGoalId || state.phase === "archived") {
+        throw new Error("No active goal. Run koan hello first.");
+    }
+    const isoDate = input.isoDate ?? new Date().toISOString();
+    const nextState = { ...state, phase: "ready", updatedAt: isoDate };
+    await executeWritePlan(projectRoot, {
+        description: "Accept current clarity as enough",
+        operations: [
+            { type: "write", path: STATE_FILES.sessionState, content: `${JSON.stringify(nextState, null, 2)}\n` }
+        ]
+    }, { log: { command: "koan enough", summary: "Accepted current clarity as enough." } });
+    return { projectRoot };
+}

package/dist/core/commandLog.d.ts

@@ -0,0 +1,8 @@
+import { type CommandLog } from "./schemas.js";
+export interface CommandLogInput {
+    command: string;
+    summary: string;
+}
+export declare function loadCommandLog(projectRoot: string): Promise<CommandLog>;
+export declare function appendCommandLogInLock(projectRoot: string, entry: CommandLogInput, isoDate?: string): Promise<CommandLog>;
+export declare function appendCommandLog(projectRoot: string, entry: CommandLogInput, isoDate?: string): Promise<CommandLog>;

package/dist/core/commandLog.js

@@ -0,0 +1,51 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { STATE_FILES } from "./constants.js";
+import { ensureStateGitignore } from "./gitPolicy.js";
+import { CommandLogEntrySchema, CommandLogSchema } from "./schemas.js";
+import { withFileLock } from "./lock.js";
+const COMMAND_LOG_LIMIT = 500;
+function freshCommandLog() {
+    return { version: 1, entries: [] };
+}
+export async function loadCommandLog(projectRoot) {
+    try {
+        const raw = await readFile(join(projectRoot, STATE_FILES.commandLog), "utf8");
+        return CommandLogSchema.parse(JSON.parse(raw));
+    }
+    catch {
+        return freshCommandLog();
+    }
+}
+// Caller must hold the project write lock.
+export async function appendCommandLogInLock(projectRoot, entry, isoDate = new Date().toISOString()) {
+    const path = join(projectRoot, STATE_FILES.commandLog);
+    const parsed = CommandLogEntrySchema.parse({ at: isoDate, command: entry.command, summary: entry.summary });
+    let current = freshCommandLog();
+    let raw = null;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        raw = null;
+    }
+    if (raw !== null) {
+        try {
+            current = CommandLogSchema.parse(JSON.parse(raw));
+        }
+        catch {
+            await writeFile(`${path}.bak`, raw, "utf8");
+        }
+    }
+    const next = {
+        version: 1,
+        entries: [...current.entries, parsed].slice(-COMMAND_LOG_LIMIT)
+    };
+    await ensureStateGitignore(projectRoot);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    return next;
+}
+export async function appendCommandLog(projectRoot, entry, isoDate = new Date().toISOString()) {
+    return withFileLock(projectRoot, () => appendCommandLogInLock(projectRoot, entry, isoDate));
+}

package/dist/core/commands.d.ts

@@ -0,0 +1,71 @@
+import { type HostId } from "./hostAdapter.js";
+import { type KoanQuestion } from "./questions.js";
+import { type AmbiguityAxis, type AnswerRecord } from "./schemas.js";
+export interface HelloResult {
+    projectRoot: string;
+    resumed: boolean;
+    activeGoalId: string | null;
+    lastAnswer: AnswerRecord | null;
+    unresolved: AmbiguityAxis[];
+    converged: boolean;
+    reconstructed: boolean;
+    nextQuestion: KoanQuestion | null;
+}
+export declare function hello(input: {
+    cwd: string;
+    homeDir: string;
+}): Promise<HelloResult>;
+export declare function status(input: {
+    cwd: string;
+}): Promise<{
+    summary: string;
+    didWrite: boolean;
+    nextAction: string;
+    staleWarnings: string[];
+}>;
+export interface UpdateStatusInput {
+    cwd: string;
+    update: string;
+    isoDate?: string;
+    source?: string;
+}
+export declare function updateStatus(input: UpdateStatusInput): Promise<{
+    projectRoot: string;
+}>;
+export declare function archive(input: {
+    cwd: string;
+}): Promise<{
+    archivedGoalId: string;
+}>;
+export type BrightIdeaClassification = "clarify" | "change-goal" | "later-follow-up" | "reject";
+export declare function brightIdea(input: {
+    cwd: string;
+    idea: string;
+    classification?: BrightIdeaClassification;
+}): Promise<{
+    classification: BrightIdeaClassification;
+    recommendation: string;
+}>;
+export declare function recordInsight(input: {
+    cwd: string;
+    text: string;
+    isoDate?: string;
+}): Promise<{
+    projectRoot: string;
+    path: string;
+}>;
+export declare function qa(input: {
+    cwd: string;
+    implementationSummary?: string;
+    host?: HostId;
+}): Promise<{
+    projectRoot: string;
+    checklist: string;
+}>;
+export declare function handoff(input: {
+    cwd: string;
+    summary: string;
+}): Promise<{
+    projectRoot: string;
+    document: string;
+}>;

package/dist/core/commands.js

@@ -0,0 +1,252 @@
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CORE_DOCUMENTS, LAZY_DOCUMENTS, STATE_FILES } from "./constants.js";
+import { loadCommandLog } from "./commandLog.js";
+import { executeWritePlan, readManagedSection, sanitizeRegionContent } from "./documents.js";
+import { buildHandoffDocument } from "./handoff.js";
+import { PHILOSOPHY_BOOTSTRAP, ensureKoanProject, findProjectRoot, loadProjectConfig } from "./project.js";
+import { ensureProfileRef } from "./profileRef.js";
+import { buildQaChecklist } from "./qa.js";
+import { defaultProfile, loadProfile, saveProfile } from "./profile.js";
+import { getQuestion } from "./questions.js";
+import { reconstructFromDocuments } from "./reconstruct.js";
+import { DEFAULT_CONVERGENCE_THRESHOLD } from "./schemas.js";
+import { createInitialLedger, isConverged, loadLedger, selectMostUnclearAxis, unresolvedAxes } from "./scoring.js";
+import { archiveGoal, createSessionState, goalIdFromDate, loadSessionState } from "./session.js";
+const STALE_SESSION_MS = 7 * 24 * 60 * 60 * 1000;
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function hello(input) {
+    const config = await ensureKoanProject(input.cwd);
+    await ensureProfileRef(config.projectRoot, input.homeDir);
+    const profile = (await loadProfile(input.homeDir)) ?? (await saveProfile(input.homeDir, defaultProfile()));
+    const existing = await loadSessionState(config.projectRoot);
+    let state;
+    let ledger;
+    let reconstructed = false;
+    let resumed = false;
+    if (existing && existing.activeGoalId && existing.phase !== "archived") {
+        const stored = await loadLedger(config.projectRoot);
+        state = existing;
+        ledger =
+            stored && stored.goalId === existing.activeGoalId
+                ? stored
+                : createInitialLedger(existing.activeGoalId);
+        resumed = true;
+    }
+    else if (!existing) {
+        const survivingLedger = await loadLedger(config.projectRoot);
+        const recovered = survivingLedger ? null : await reconstructFromDocuments(config.projectRoot);
+        if (survivingLedger) {
+            state = createSessionState(survivingLedger.goalId);
+            ledger = survivingLedger;
+        }
+        else if (recovered && recovered.sources.length > 0) {
+            state = recovered.state;
+            ledger = recovered.ledger;
+            reconstructed = true;
+        }
+        else {
+            const goalId = goalIdFromDate();
+            state = createSessionState(goalId);
+            ledger = createInitialLedger(goalId);
+        }
+    }
+    else {
+        const goalId = goalIdFromDate();
+        state = createSessionState(goalId);
+        ledger = createInitialLedger(goalId);
+    }
+    await executeWritePlan(config.projectRoot, {
+        description: "Persist session state and ambiguity ledger",
+        operations: [
+            { type: "write", path: STATE_FILES.sessionState, content: `${JSON.stringify(state, null, 2)}\n` },
+            { type: "write", path: STATE_FILES.ambiguityLedger, content: `${JSON.stringify(ledger, null, 2)}\n` }
+        ]
+    }, { log: { command: "koan hello", summary: "Initialized or resumed Koan session." } });
+    const threshold = config.settings.convergenceThreshold;
+    const converged = state.phase === "ready" || isConverged(ledger, threshold);
+    return {
+        projectRoot: config.projectRoot,
+        resumed,
+        activeGoalId: state.activeGoalId,
+        lastAnswer: state.answers.at(-1) ?? null,
+        unresolved: unresolvedAxes(ledger, threshold),
+        converged,
+        reconstructed,
+        nextQuestion: converged ? null : getQuestion(selectMostUnclearAxis(ledger), profile)
+    };
+}
+export async function status(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const goal = await readFile(join(projectRoot, CORE_DOCUMENTS.goal), "utf8").catch(() => "# Goal\n");
+    const current = await readFile(join(projectRoot, CORE_DOCUMENTS.status), "utf8").catch(() => "# Status\n");
+    const session = await loadSessionState(projectRoot);
+    const ledger = await loadLedger(projectRoot);
+    const threshold = (await loadProjectConfig(projectRoot))?.settings.convergenceThreshold ?? DEFAULT_CONVERGENCE_THRESHOLD;
+    let nextAction;
+    if (!session) {
+        nextAction = "run koan hello";
+    }
+    else if (session.phase === "archived" || !session.activeGoalId) {
+        nextAction = "run koan hello to start a new goal";
+    }
+    else if (session.phase === "ready" ||
+        (ledger !== null && ledger.goalId === session.activeGoalId && isConverged(ledger, threshold))) {
+        nextAction = "archive the completed goal (koan status --archive)";
+    }
+    else if (!ledger || ledger.goalId !== session.activeGoalId) {
+        nextAction = "run koan hello";
+    }
+    else {
+        nextAction = `answer the ${selectMostUnclearAxis(ledger)} question (${unresolvedAxes(ledger, threshold).length} axes unresolved)`;
+    }
+    const staleWarnings = [];
+    if (session && Date.now() - Date.parse(session.updatedAt) > STALE_SESSION_MS) {
+        staleWarnings.push(`session state is stale (last updated ${session.updatedAt})`);
+    }
+    if (session && session.answers.length > 0) {
+        const log = await loadCommandLog(projectRoot);
+        const lastCrystallize = [...log.entries].reverse().find((entry) => entry.command === "koan crystallize");
+        const lastAnswer = session.answers.at(-1);
+        if (lastAnswer &&
+            (!lastCrystallize || Date.parse(lastCrystallize.at) < Date.parse(lastAnswer.recordedAt))) {
+            staleWarnings.push("recorded answers are not crystallized yet (run koan crystallize)");
+        }
+    }
+    let summary = `Active Goal\n\n${goal}\n\nCurrent Status\n\n${current}\n\nNext action: ${nextAction}`;
+    if (staleWarnings.length > 0) {
+        summary += `\n\nWarnings:\n${staleWarnings.map((warning) => `- ${warning}`).join("\n")}`;
+    }
+    return { summary, didWrite: false, nextAction, staleWarnings };
+}
+export async function updateStatus(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const state = await loadSessionState(projectRoot);
+    if (!state)
+        throw new Error("No active Koan session. Run koan hello first.");
+    const update = sanitizeRegionContent(input.update.trim());
+    if (!update)
+        throw new Error("Status update text is required.");
+    const isoDate = input.isoDate ?? new Date().toISOString();
+    const operations = [
+        { type: "managed-region", path: CORE_DOCUMENTS.status, name: "current-status", content: update }
+    ];
+    if (!(await exists(join(projectRoot, LAZY_DOCUMENTS.handoff)))) {
+        operations.push({ type: "write", path: LAZY_DOCUMENTS.handoff, content: "# Handoff\n" });
+    }
+    operations.push({
+        type: "managed-region",
+        path: LAZY_DOCUMENTS.handoff,
+        name: "latest-status",
+        content: `${update}\n\n(Updated ${isoDate} via koan status)`
+    }, {
+        type: "write",
+        path: STATE_FILES.sessionState,
+        content: `${JSON.stringify({ ...state, updatedAt: isoDate }, null, 2)}\n`
+    });
+    const source = input.source?.trim();
+    await executeWritePlan(projectRoot, { description: "Record status update", operations }, {
+        log: {
+            command: "koan status",
+            summary: source ? `Recorded a status update (source: ${source}).` : "Recorded a status update."
+        }
+    });
+    return { projectRoot };
+}
+export async function archive(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const state = await loadSessionState(projectRoot);
+    if (!state?.activeGoalId)
+        throw new Error("No active goal to archive.");
+    const goalId = state.activeGoalId;
+    await archiveGoal(projectRoot, goalId, { command: "koan archive", summary: `Archived goal ${goalId}.` });
+    return { archivedGoalId: goalId };
+}
+const BRIGHT_IDEA_RECOMMENDATIONS = {
+    clarify: "Refine the current goal with koan hello before implementing.",
+    "change-goal": "Archive or re-scope the current goal before adopting this direction.",
+    "later-follow-up": "Keep the current plan; revisit this after the active goal completes.",
+    reject: "Recorded for reference; no action planned."
+};
+export async function brightIdea(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const classification = input.classification ?? "later-follow-up";
+    const entry = `## ${new Date().toISOString()} — koan bright-idea\n\nClassification: ${classification}\n\n${sanitizeRegionContent(input.idea.trim())}`;
+    await executeWritePlan(projectRoot, {
+        description: "Record bright idea",
+        operations: [
+            {
+                type: "append",
+                path: LAZY_DOCUMENTS.brightIdeas,
+                content: entry,
+                headerIfMissing: "# Bright Ideas"
+            }
+        ]
+    }, { log: { command: "koan bright-idea", summary: "Recorded a bright idea." } });
+    return { classification, recommendation: BRIGHT_IDEA_RECOMMENDATIONS[classification] };
+}
+// Append-only by design: insights are a chronicle of how the product's "why"
+// sharpened over time, so later entries never replace earlier ones.
+export async function recordInsight(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const text = sanitizeRegionContent(input.text.trim());
+    if (!text)
+        throw new Error("Insight text is required.");
+    const isoDate = input.isoDate ?? new Date().toISOString();
+    await executeWritePlan(projectRoot, {
+        description: "Record insight",
+        operations: [
+            {
+                type: "append",
+                path: LAZY_DOCUMENTS.philosophy,
+                content: `## ${isoDate} — koan insight\n\n${text}`,
+                headerIfMissing: PHILOSOPHY_BOOTSTRAP
+            }
+        ]
+    }, { log: { command: "koan insight", summary: "Recorded an insight." } });
+    return { projectRoot, path: LAZY_DOCUMENTS.philosophy };
+}
+export async function qa(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const goalText = await readFile(join(projectRoot, CORE_DOCUMENTS.goal), "utf8").catch(() => null);
+    const planText = await readFile(join(projectRoot, CORE_DOCUMENTS.plan), "utf8").catch(() => null);
+    let checklist = buildQaChecklist({
+        activeGoal: goalText === null ? null : readManagedSection(goalText, "active-goal"),
+        planSection: planText === null ? null : readManagedSection(planText, "implementation-plan")
+    }, input.host ?? "generic");
+    if (input.implementationSummary !== undefined) {
+        checklist += `\n## Implementation Summary (host-provided)\n\n${input.implementationSummary.trim()}\n`;
+    }
+    checklist = sanitizeRegionContent(checklist);
+    // A managed-region write only touches the qa-checklist region, so manual
+    // edits outside the markers and the crystallized qa-criteria region survive.
+    await executeWritePlan(projectRoot, {
+        description: "Create QA checklist",
+        operations: [
+            { type: "managed-region", path: LAZY_DOCUMENTS.qa, name: "qa-checklist", content: checklist }
+        ]
+    }, { log: { command: "koan qa", summary: "Generated QA checklist." } });
+    return { projectRoot, checklist };
+}
+export async function handoff(input) {
+    const projectRoot = await findProjectRoot(input.cwd);
+    const content = sanitizeRegionContent(buildHandoffDocument({ summary: input.summary, experimentalHandoff: false }));
+    // A managed-region write only touches the handoff-document region, so manual
+    // edits outside the markers and the latest-status / crystallized
+    // handoff-context regions survive.
+    await executeWritePlan(projectRoot, {
+        description: "Create handoff",
+        operations: [
+            { type: "managed-region", path: LAZY_DOCUMENTS.handoff, name: "handoff-document", content }
+        ]
+    }, { log: { command: "koan handoff", summary: "Created handoff document." } });
+    return { projectRoot, document: content };
+}

package/dist/core/constants.d.ts

@@ -0,0 +1,32 @@
+export declare const KOAN_VERSION = "0.2.0";
+export declare const KOAN_DIR = "koan";
+export declare const KOAN_STATE_DIR = ".koan";
+export declare const CORE_DOCUMENTS: {
+    readonly readme: "koan/README.md";
+    readonly goal: "koan/goal.md";
+    readonly status: "koan/status.md";
+    readonly plan: "koan/plan.md";
+};
+export declare const LAZY_DOCUMENTS: {
+    readonly philosophy: "koan/philosophy.md";
+    readonly decisions: "koan/decisions.md";
+    readonly openQuestions: "koan/open-questions.md";
+    readonly qa: "koan/qa.md";
+    readonly handoff: "koan/handoff.md";
+    readonly brightIdeas: "koan/bright-ideas.md";
+    readonly prd: "koan/prd.md";
+};
+export declare const STATE_FILES: {
+    readonly project: ".koan/project.json";
+    readonly userProfileRef: ".koan/user-profile-ref.json";
+    readonly sessionState: ".koan/session-state.json";
+    readonly ambiguityLedger: ".koan/ambiguity-ledger.json";
+    readonly commandLog: ".koan/command-log.json";
+    readonly mcpCache: ".koan/mcp-cache.json";
+    readonly gitignore: ".koan/.gitignore";
+    readonly lock: ".koan/write.lock";
+};
+export declare const BOOTSTRAP_START = "<!-- koan:start -->";
+export declare const BOOTSTRAP_END = "<!-- koan:end -->";
+export declare function managedStart(name: string): string;
+export declare function managedEnd(name: string): string;

package/dist/core/constants.js

@@ -0,0 +1,36 @@
+export const KOAN_VERSION = "0.2.0";
+export const KOAN_DIR = "koan";
+export const KOAN_STATE_DIR = ".koan";
+export const CORE_DOCUMENTS = {
+    readme: "koan/README.md",
+    goal: "koan/goal.md",
+    status: "koan/status.md",
+    plan: "koan/plan.md"
+};
+export const LAZY_DOCUMENTS = {
+    philosophy: "koan/philosophy.md",
+    decisions: "koan/decisions.md",
+    openQuestions: "koan/open-questions.md",
+    qa: "koan/qa.md",
+    handoff: "koan/handoff.md",
+    brightIdeas: "koan/bright-ideas.md",
+    prd: "koan/prd.md"
+};
+export const STATE_FILES = {
+    project: ".koan/project.json",
+    userProfileRef: ".koan/user-profile-ref.json",
+    sessionState: ".koan/session-state.json",
+    ambiguityLedger: ".koan/ambiguity-ledger.json",
+    commandLog: ".koan/command-log.json",
+    mcpCache: ".koan/mcp-cache.json",
+    gitignore: ".koan/.gitignore",
+    lock: ".koan/write.lock"
+};
+export const BOOTSTRAP_START = "<!-- koan:start -->";
+export const BOOTSTRAP_END = "<!-- koan:end -->";
+export function managedStart(name) {
+    return `<!-- koan:section:start name="${name}" -->`;
+}
+export function managedEnd(name) {
+    return `<!-- koan:section:end name="${name}" -->`;
+}

package/dist/core/crystallize.d.ts

@@ -0,0 +1,15 @@
+import { type AmbiguityAxis, type WritePlan } from "./schemas.js";
+export interface CrystallizeInput {
+    cwd: string;
+    homeDir: string;
+    dryRun?: boolean;
+    isoDate?: string;
+}
+export interface CrystallizeResult {
+    projectRoot: string;
+    plan: WritePlan;
+    executed: boolean;
+    files: string[];
+    crystallizedAxes: AmbiguityAxis[];
+}
+export declare function crystallize(input: CrystallizeInput): Promise<CrystallizeResult>;