@jigx/sdk-tools 1.2.0-next.2 → 1.2.0-next.4

package/dist/migrator/converters/translations.js

@@ -0,0 +1,25 @@
+import { countNodes } from '../report.js';
+import { lit, str } from '../ts-printer.js';
+/** `translations/<locale>.jigx` → `app.translation('<locale>', { … })` (node-free data only). */
+export function convertTranslation(entry) {
+    const { id, entity } = entry;
+    if (countNodes({ value: entity, asRoot: false }) > 0) {
+        return {
+            type: 'skip',
+            gapId: 'translations:contains-nodes',
+            reason: 'app.translation() takes untyped data, which must not carry component or action nodes',
+        };
+    }
+    return {
+        type: 'statements',
+        statements: [
+            {
+                code: `app.translation(${str(id)}, ${lit(entity, '  ')})`,
+                run: (app) => {
+                    app.translation(id, entity);
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=translations.js.map

package/dist/migrator/converters/translations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.js","sourceRoot":"","sources":["../../../src/migrator/converters/translations.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAG3C,iGAAiG;AACjG,MAAM,UAAU,kBAAkB,CAAC,KAAkB;IACnD,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,KAAK,CAAA;IAC5B,IAAI,UAAU,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;QACrD,OAAO;YACL,IAAI,EAAE,MAAM;YACZ,KAAK,EAAE,6BAA6B;YACpC,MAAM,EACJ,sFAAsF;SACzF,CAAA;IACH,CAAC;IACD,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,UAAU,EAAE;YACV;gBACE,IAAI,EAAE,mBAAmB,GAAG,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG;gBACzD,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE;oBACX,GAAG,CAAC,WAAW,CAAC,EAAE,EAAE,MAAM,CAAC,CAAA;gBAC7B,CAAC;aACF;SACF;KACF,CAAA;AACH,CAAC"}

package/dist/migrator/converters/types.d.ts

@@ -0,0 +1,35 @@
+import { type ApplicationBuilder } from '@jigx/core-sdk';
+import { type LegacyEntry } from '../read-solution.js';
+import { type NodeGap } from '../report.js';
+/**
+ * One typed core-sdk call: its generated source and the same call, replayed in-process.
+ *
+ * `code` is written at the register-body indent; continuation lines carry their own indent.
+ */
+export interface Statement {
+    readonly code: string;
+    readonly run: (app: ApplicationBuilder) => void;
+}
+/** An entity with no exact typed mapping: no module is generated. */
+interface EntitySkip {
+    readonly type: 'skip';
+    readonly gapId: string;
+    readonly reason: string;
+    /** Node type of the gap; defaults to the entity kind. */
+    readonly nodeType?: string;
+}
+/** An entity migrated into typed statements. */
+interface EntityStatements {
+    readonly type: 'statements';
+    readonly statements: readonly Statement[];
+    /** Extra import lines the statements need. */
+    readonly imports?: readonly string[];
+    /** Files copied verbatim into the project, keyed by project relPath. */
+    readonly copies?: Readonly<Record<string, string>>;
+    /** Nodes skipped inside the entity (node-level gaps). */
+    readonly gaps?: readonly NodeGap[];
+}
+export type EntityConversion = EntitySkip | EntityStatements;
+export type EntityConverter = (entry: LegacyEntry) => EntityConversion;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/migrator/converters/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/migrator/converters/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,kBAAkB,KAAK,IAAI,CAAA;CAChD;AAED,qEAAqE;AACrE,UAAU,UAAU;IAClB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,gDAAgD;AAChD,UAAU,gBAAgB;IACxB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAA;IACzC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACpC,wEAAwE;IACxE,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAClD,yDAAyD;IACzD,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;CACnC;AAED,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,gBAAgB,CAAA;AAE5D,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,gBAAgB,CAAA"}

package/dist/migrator/converters/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/migrator/converters/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/migrator/converters/types.ts"],"names":[],"mappings":""}

package/dist/migrator/errors.d.ts

@@ -0,0 +1,5 @@
+/** Thrown when a legacy solution cannot be migrated (invalid input, unsafe output location, unreadable YAML). */
+export declare class MigrateError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/migrator/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/migrator/errors.ts"],"names":[],"mappings":"AAAA,iHAAiH;AACjH,qBAAa,YAAa,SAAQ,KAAK;IACrC,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF"}

package/dist/migrator/errors.js

@@ -0,0 +1,8 @@
+/** Thrown when a legacy solution cannot be migrated (invalid input, unsafe output location, unreadable YAML). */
+export class MigrateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MigrateError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/migrator/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/migrator/errors.ts"],"names":[],"mappings":"AAAA,iHAAiH;AACjH,MAAM,OAAO,YAAa,SAAQ,KAAK;IACrC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,cAAc,CAAA;IAC5B,CAAC;CACF"}

package/dist/migrator/index.d.ts

@@ -0,0 +1,6 @@
+export { MigrateError } from './errors.js';
+export { checkBuild, migrate } from './migrate.js';
+export type { CheckBuildOptions, CheckBuildResult, EntityMismatch, MigrateOptions, MigrateResult, } from './migrate.js';
+export { summarizeGaps } from './report.js';
+export type { GapRecord, MigrationReport } from './report.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/migrator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAClD,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,aAAa,GACd,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,YAAY,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA"}

package/dist/migrator/index.js

@@ -0,0 +1,4 @@
+export { MigrateError } from './errors.js';
+export { checkBuild, migrate } from './migrate.js';
+export { summarizeGaps } from './report.js';
+//# sourceMappingURL=index.js.map

package/dist/migrator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/migrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAQlD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}

package/dist/migrator/migrate.d.ts

@@ -0,0 +1,75 @@
+import { type ProjectFile } from './project-writer.js';
+import { type EntityKind, type LegacyEntry } from './read-solution.js';
+import { type MigrationReport } from './report.js';
+export interface MigrateOptions {
+    /** Legacy solution folder (holds `index.jigx` and the kind folders). */
+    readonly solutionDir: string;
+    /** Project dir to write. Defaults to `<cwd>/<index name>`. */
+    readonly outDir?: string;
+    /** Overwrite an existing out dir (its `src/` is replaced; other files are kept). */
+    readonly force?: boolean;
+    /** Base for relative paths. Defaults to `process.cwd()`. */
+    readonly cwd?: string;
+}
+export interface MigrateResult {
+    readonly outDir: string;
+    readonly report: MigrationReport;
+    /** Absolute paths of every file written. */
+    readonly filesWritten: readonly string[];
+}
+export interface PlanMigrationOptions {
+    readonly entries: readonly LegacyEntry[];
+    readonly ignored?: readonly string[];
+}
+export interface MigrationPlan {
+    readonly applicationName: string;
+    /** Every project file, including `migration-report.json`. */
+    readonly files: readonly ProjectFile[];
+    readonly report: MigrationReport;
+    /** The in-process build of the replayed, verified calls. */
+    readonly built: Readonly<Record<string, unknown>>;
+}
+/**
+ * Plans a migration in memory: converts every entry, replays the typed calls on one
+ * ApplicationBuilder, verifies each entity against the pruned legacy (demoting
+ * mismatches to `<kind>:composition-differs`) and renders the project files.
+ * @throws MigrateError when there is no valid `index.jigx` entry
+ */
+export declare function planMigration(options: PlanMigrationOptions): MigrationPlan;
+/**
+ * Migrates a legacy YAML solution into a typed core-sdk TypeScript project.
+ *
+ * Writes `package.json`, `tsconfig.json`, `.gitignore`, `src/app.ts`, one module per
+ * migrated entity, verbatim scripts and `migration-report.json` into `outDir`.
+ * @throws MigrateError when the solution is invalid, or `outDir` exists (without `force`)
+ * or overlaps the solution dir
+ */
+export declare function migrate(options: MigrateOptions): Promise<MigrateResult>;
+export interface CheckBuildOptions {
+    /** Legacy solution folder the project was migrated from. */
+    readonly solutionDir: string;
+    /** Migrated project dir holding `migration-report.json` and `build/output.json` (after `jigx build`). */
+    readonly projectDir: string;
+    /** Base for relative paths. Defaults to `process.cwd()`. */
+    readonly cwd?: string;
+}
+/** One entity whose built output differs from the pruned legacy. */
+export interface EntityMismatch {
+    readonly kind: EntityKind;
+    readonly id: string;
+    /** Top-level keys whose values differ; empty when the entity is missing on one side. */
+    readonly differingKeys: readonly string[];
+}
+export interface CheckBuildResult {
+    /** Entities compared (both sides, index included). */
+    readonly checked: number;
+    readonly mismatches: readonly EntityMismatch[];
+}
+/**
+ * Checks an already built migrated project: compares its `build/output.json` with the
+ * pruned legacy solution, entity by entity, using the gaps in its `migration-report.json`.
+ * Proves the generated source builds to the same result as the in-process replay. Writes nothing.
+ * @throws MigrateError when the solution is invalid, or the report or build output is missing or malformed
+ */
+export declare function checkBuild(options: CheckBuildOptions): Promise<CheckBuildResult>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/migrator/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../src/migrator/migrate.ts"],"names":[],"mappings":"AA8BA,OAAO,EAAiB,KAAK,WAAW,EAAsB,MAAM,qBAAqB,CAAA;AAEzF,OAAO,EAGL,KAAK,UAAU,EACf,KAAK,WAAW,EAEjB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAGL,KAAK,eAAe,EAGrB,MAAM,aAAa,CAAA;AAGpB,MAAM,WAAW,cAAc;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,8DAA8D;IAC9D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,oFAAoF;IACpF,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAA;IACxB,4DAA4D;IAC5D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;IAChC,4CAA4C;IAC5C,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;CACzC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAA;IACxC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACrC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;IACtC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD;AAyQD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CA+C1E;AAgCD;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CA8B7E;AAED,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,yGAAyG;IACzG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,4DAA4D;IAC5D,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,oEAAoE;AACpE,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,wFAAwF;IACxF,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1C;AAED,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAA;CAC/C;AA2CD;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA8CtF"}

package/dist/migrator/migrate.js

@@ -0,0 +1,439 @@
+import { mkdir, readFile, realpath, rm, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { ApplicationBuilder, PACKAGE } from '@jigx/core-sdk';
+import { applicationInput, convertAsset, convertComponent, convertDatabase, convertDatasource, convertFunction, convertIndex, convertScript, convertTranslation, indexKeyGapId, renderIndexModule, SCRIPTS_MODULE_PATH, } from './converters/index.js';
+import { MigrateError } from './errors.js';
+import { renderModule } from './module-writer.js';
+import { convertAction, convertJig } from './nodes/index.js';
+import { assembleLegacy, isPlainObject, toComparable, } from './normalize.js';
+import { renderProjectFiles } from './project-writer.js';
+import { prune, pruneBuilt } from './prune.js';
+import { compareText, ENTITY_KINDS, readSolution, } from './read-solution.js';
+import { countNodes, sortGaps, } from './report.js';
+import { verifyEntity } from './verify-entity.js';
+const REPORT_FILE = 'migration-report.json';
+const CONVERTERS = {
+    databases: convertDatabase,
+    functions: convertFunction,
+    datasources: convertDatasource,
+    actions: convertAction,
+    components: convertComponent,
+    jigs: convertJig,
+    translations: convertTranslation,
+    assets: convertAsset,
+    scripts: convertScript,
+};
+function compositionGapId(kind) {
+    return `${kind}:composition-differs`;
+}
+function firstLine(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.split('\n')[0] ?? message;
+}
+function demoteEntity(states, position, reason) {
+    const state = states.at(position);
+    if (!state)
+        return;
+    states[position] = {
+        entry: state.entry,
+        conversion: { type: 'skip', gapId: compositionGapId(state.entry.kind), reason },
+    };
+}
+function demoteIndexKey(keys, key, reason) {
+    const position = keys.findIndex((item) => item.key === key);
+    if (position === -1)
+        return false;
+    const current = keys.at(position);
+    if (!current || current.type === 'skip' || key === 'name')
+        return false;
+    keys[position] = { type: 'skip', key, gapId: indexKeyGapId(key), reason };
+    return true;
+}
+function collectGaps(options) {
+    const { indexEntry, indexKeys, states } = options;
+    const legacyIndex = isPlainObject(indexEntry.entity) ? indexEntry.entity : {};
+    const gaps = [];
+    const nodeGaps = (relPath, list = []) => {
+        for (const { path, ...gap } of list)
+            gaps.push({ ...gap, location: { relPath, path } });
+    };
+    for (const key of indexKeys) {
+        if (key.type === 'statements')
+            nodeGaps(indexEntry.relPath, key.gaps);
+        if (key.type !== 'skip')
+            continue;
+        gaps.push({
+            gapId: key.gapId,
+            nodeType: key.nodeType ?? 'index',
+            reason: key.reason,
+            skippedNodes: countNodes({ value: legacyIndex[key.key], asRoot: false }),
+            location: { relPath: indexEntry.relPath, path: [key.key] },
+        });
+    }
+    for (const { entry, conversion } of states) {
+        if (conversion.type === 'statements') {
+            nodeGaps(entry.relPath, conversion.gaps);
+            continue;
+        }
+        gaps.push({
+            gapId: conversion.gapId,
+            nodeType: conversion.nodeType ?? entry.kind,
+            reason: conversion.reason,
+            skippedNodes: countNodes({ value: entry.entity, asRoot: true }),
+            location: { relPath: entry.relPath, path: [] },
+        });
+    }
+    return sortGaps(gaps);
+}
+/** Replays the index and every verified entity on one ApplicationBuilder; demotes what throws. */
+function compose(options) {
+    const { index, indexKeys, states } = options;
+    const app = new ApplicationBuilder(applicationInput({ ...index, keys: indexKeys }));
+    for (const key of indexKeys) {
+        if (key.type !== 'statements')
+            continue;
+        try {
+            for (const statement of key.statements)
+                statement.run(app);
+        }
+        catch (error) {
+            demoteIndexKey(indexKeys, key.key, `replaying the typed calls throws: ${firstLine(error)}`);
+            return undefined;
+        }
+    }
+    for (const [position, { conversion }] of states.entries()) {
+        if (conversion.type !== 'statements')
+            continue;
+        try {
+            for (const statement of conversion.statements)
+                statement.run(app);
+        }
+        catch (error) {
+            demoteEntity(states, position, `replaying the typed calls throws: ${firstLine(error)}`);
+            return undefined;
+        }
+    }
+    return app;
+}
+/**
+ * Builds the composed Application and verifies every entity against the pruned legacy.
+ * Returns the build when everything verifies; demotes the first mismatches otherwise.
+ */
+function verifyComposition(options) {
+    const { app, entries, indexEntry, indexKeys, states } = options;
+    let built;
+    try {
+        built = app.build();
+    }
+    catch (error) {
+        throw new MigrateError(`Building the migrated Application failed: ${firstLine(error)}`);
+    }
+    const gaps = collectGaps({ indexEntry, indexKeys, states });
+    const builtComparable = pruneBuilt({ built: toComparable(built), entries, gaps });
+    const legacyComparable = toComparable(assembleLegacy(prune({ entries, gaps })));
+    let demoted = false;
+    const index = verifyEntity({
+        kind: 'index',
+        id: 'index',
+        built: builtComparable,
+        legacy: legacyComparable,
+    });
+    for (const key of index.differingKeys) {
+        if (demoteIndexKey(indexKeys, key, 'the composed index differs from the legacy index')) {
+            demoted = true;
+        }
+        else {
+            throw new MigrateError(`${indexEntry.relPath}: the built index differs from the legacy index in "${key}", which cannot be skipped`);
+        }
+    }
+    if (!index.equal && index.differingKeys.length === 0) {
+        throw new MigrateError(`${indexEntry.relPath}: the built index differs from the legacy index`);
+    }
+    for (const [position, { entry, conversion }] of states.entries()) {
+        if (conversion.type === 'skip')
+            continue;
+        const { kind, id } = entry;
+        const { equal, differingKeys } = verifyEntity({
+            kind,
+            id,
+            built: builtComparable,
+            legacy: legacyComparable,
+        });
+        if (!equal) {
+            const where = differingKeys.length > 0 ? ` in: ${differingKeys.join(', ')}` : '';
+            demoteEntity(states, position, `the composed entity differs from the legacy entity${where}`);
+            demoted = true;
+        }
+    }
+    return demoted ? undefined : built;
+}
+/** Module path under `src/` for a legacy relPath: extension dropped, URL-unsafe characters replaced. */
+function modulePathFor(relPath) {
+    return relPath
+        .replace(/\.jigx$/, '')
+        .split('/')
+        .map((segment) => segment.replace(/[^A-Za-z0-9._ -]/g, '-'))
+        .join('/');
+}
+function uniqueModulePath(relPath, used) {
+    const base = modulePathFor(relPath);
+    let candidate = base;
+    for (let suffix = 2; used.has(candidate.toLowerCase()); suffix++)
+        candidate = `${base}-${suffix}`;
+    used.add(candidate.toLowerCase());
+    return candidate;
+}
+function renderFiles(options) {
+    const { indexEntry, index, states, report } = options;
+    const files = [
+        {
+            relPath: 'src/index.ts',
+            content: renderIndexModule({ relPath: indexEntry.relPath, conversion: index }),
+        },
+    ];
+    const appEntries = [{ type: 'module', modulePath: 'index' }];
+    const usedPaths = new Set(['index', 'app', SCRIPTS_MODULE_PATH]);
+    const scriptSources = [];
+    const scriptImports = new Set();
+    const scriptBody = [];
+    for (const { entry, conversion } of states) {
+        if (conversion.type === 'skip') {
+            appEntries.push({
+                type: 'todo',
+                gapId: conversion.gapId,
+                reason: conversion.reason,
+                relPath: entry.relPath,
+            });
+            continue;
+        }
+        for (const [relPath, content] of Object.entries(conversion.copies ?? {})) {
+            files.push({ relPath, content });
+        }
+        const body = conversion.statements.map((statement) => statement.code);
+        if (entry.kind === 'scripts') {
+            if (scriptSources.length === 0)
+                appEntries.push({ type: 'module', modulePath: SCRIPTS_MODULE_PATH });
+            scriptSources.push(entry.relPath);
+            for (const line of conversion.imports ?? [])
+                scriptImports.add(line);
+            scriptBody.push(...body);
+            continue;
+        }
+        const modulePath = uniqueModulePath(entry.relPath, usedPaths);
+        appEntries.push({ type: 'module', modulePath });
+        files.push({
+            relPath: `src/${modulePath}.ts`,
+            content: renderModule({ sources: [entry.relPath], imports: conversion.imports, body }),
+        });
+    }
+    if (scriptSources.length > 0) {
+        files.push({
+            relPath: `src/${SCRIPTS_MODULE_PATH}.ts`,
+            content: renderModule({
+                sources: scriptSources,
+                imports: [...scriptImports],
+                body: scriptBody,
+            }),
+        });
+    }
+    return [
+        ...renderProjectFiles({
+            applicationName: index.name,
+            coreSdkVersion: report.coreSdkVersion,
+            entries: appEntries,
+        }),
+        ...files,
+        { relPath: REPORT_FILE, content: `${JSON.stringify(report, null, 2)}\n` },
+    ];
+}
+/**
+ * Plans a migration in memory: converts every entry, replays the typed calls on one
+ * ApplicationBuilder, verifies each entity against the pruned legacy (demoting
+ * mismatches to `<kind>:composition-differs`) and renders the project files.
+ * @throws MigrateError when there is no valid `index.jigx` entry
+ */
+export function planMigration(options) {
+    const { entries, ignored = [] } = options;
+    const indexEntry = entries.find((entry) => entry.kind === 'index');
+    if (!indexEntry)
+        throw new MigrateError('Missing index.jigx');
+    const index = convertIndex(indexEntry);
+    const indexKeys = [...index.keys];
+    const states = entries
+        .filter((entry) => entry.kind !== 'index')
+        .map((entry) => ({ entry, conversion: CONVERTERS[entry.kind](entry) }));
+    // Each round either verifies everything or demotes at least one key or entity.
+    const maxRounds = indexKeys.length + states.length + 1;
+    let built;
+    for (let round = 0; round < maxRounds && !built; round++) {
+        const app = compose({ index, indexKeys, states });
+        if (app)
+            built = verifyComposition({ app, entries, indexEntry, indexKeys, states });
+    }
+    if (!built)
+        throw new MigrateError('Entity verification did not converge');
+    const gaps = collectGaps({ indexEntry, indexKeys, states });
+    const totalNodes = entries.reduce((sum, entry) => sum + countNodes({ value: entry.entity, asRoot: true }), 0);
+    const skippedNodes = gaps.reduce((sum, gap) => sum + gap.skippedNodes, 0);
+    const skippedEntities = states.filter((state) => state.conversion.type === 'skip').length;
+    const report = {
+        coreSdkVersion: PACKAGE.VERSION,
+        entities: {
+            total: entries.length,
+            migrated: entries.length - skippedEntities,
+            skipped: skippedEntities,
+        },
+        nodes: { total: totalNodes, typed: totalNodes - skippedNodes, skipped: skippedNodes },
+        gaps,
+        ignored,
+    };
+    const finalIndex = { ...index, keys: indexKeys };
+    return {
+        applicationName: index.name,
+        files: renderFiles({ indexEntry, index: finalIndex, states, report }),
+        report,
+        built,
+    };
+}
+async function exists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+/** Resolves symlinks of the longest existing prefix of `target` (the rest may not exist yet). */
+async function realpathLoose(target) {
+    const rest = [];
+    let current = target;
+    for (;;) {
+        try {
+            return path.join(await realpath(current), ...rest.reverse());
+        }
+        catch {
+            const parent = path.dirname(current);
+            if (parent === current)
+                return target;
+            rest.push(path.basename(current));
+            current = parent;
+        }
+    }
+}
+function overlaps(a, b) {
+    return a === b || a.startsWith(`${b}${path.sep}`) || b.startsWith(`${a}${path.sep}`);
+}
+/**
+ * Migrates a legacy YAML solution into a typed core-sdk TypeScript project.
+ *
+ * Writes `package.json`, `tsconfig.json`, `.gitignore`, `src/app.ts`, one module per
+ * migrated entity, verbatim scripts and `migration-report.json` into `outDir`.
+ * @throws MigrateError when the solution is invalid, or `outDir` exists (without `force`)
+ * or overlaps the solution dir
+ */
+export async function migrate(options) {
+    const { force = false, cwd = process.cwd() } = options;
+    const solutionDir = path.resolve(cwd, options.solutionDir);
+    const solution = await readSolution({ solutionDir });
+    const plan = planMigration({ entries: solution.entries, ignored: solution.ignored });
+    const outDir = path.resolve(cwd, options.outDir ?? plan.applicationName);
+    const [realSolution, realOut] = await Promise.all([
+        realpathLoose(solutionDir),
+        realpathLoose(outDir),
+    ]);
+    if (overlaps(solutionDir, outDir) || overlaps(realSolution, realOut)) {
+        throw new MigrateError(`Out dir ${outDir} must not be, contain, or sit inside the solution dir ${solutionDir}`);
+    }
+    if (await exists(outDir)) {
+        if (!force)
+            throw new MigrateError(`Out dir already exists: ${outDir}. Pass --force to overwrite it.`);
+        await rm(path.join(outDir, 'src'), { recursive: true, force: true });
+    }
+    const filesWritten = [];
+    for (const file of plan.files) {
+        const absPath = path.join(outDir, file.relPath);
+        await mkdir(path.dirname(absPath), { recursive: true });
+        await writeFile(absPath, file.content, 'utf8');
+        filesWritten.push(absPath);
+    }
+    return { outDir, report: plan.report, filesWritten };
+}
+function isGapLocationRecord(value) {
+    if (!isPlainObject(value) || !isPlainObject(value.location))
+        return false;
+    const { relPath, path: nodePath } = value.location;
+    return (typeof relPath === 'string' &&
+        Array.isArray(nodePath) &&
+        nodePath.every((segment) => typeof segment === 'string' || typeof segment === 'number'));
+}
+async function readJson(options) {
+    const { filePath, hint } = options;
+    let text;
+    try {
+        text = await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            throw new MigrateError(`Missing ${filePath}. ${hint}`);
+        }
+        throw error;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new MigrateError(`${filePath} is not valid JSON: ${firstLine(error)}`);
+    }
+}
+function entityKeys(comparable) {
+    return ENTITY_KINDS.flatMap((kind) => Object.keys(comparable[kind] ?? {}).map((id) => [kind, id]));
+}
+/**
+ * Checks an already built migrated project: compares its `build/output.json` with the
+ * pruned legacy solution, entity by entity, using the gaps in its `migration-report.json`.
+ * Proves the generated source builds to the same result as the in-process replay. Writes nothing.
+ * @throws MigrateError when the solution is invalid, or the report or build output is missing or malformed
+ */
+export async function checkBuild(options) {
+    const { cwd = process.cwd() } = options;
+    const solutionDir = path.resolve(cwd, options.solutionDir);
+    const projectDir = path.resolve(cwd, options.projectDir);
+    const report = await readJson({
+        filePath: path.join(projectDir, REPORT_FILE),
+        hint: 'Run jigx migrate first.',
+    });
+    if (!isPlainObject(report) || !Array.isArray(report.gaps)) {
+        throw new MigrateError(`${path.join(projectDir, REPORT_FILE)} has no gaps list`);
+    }
+    const gaps = report.gaps.filter(isGapLocationRecord);
+    if (gaps.length !== report.gaps.length) {
+        throw new MigrateError(`${path.join(projectDir, REPORT_FILE)} has a gap without a valid location`);
+    }
+    const output = await readJson({
+        filePath: path.join(projectDir, 'build', 'output.json'),
+        hint: 'Run jigx build in the project first.',
+    });
+    if (!isPlainObject(output)) {
+        throw new MigrateError(`${path.join(projectDir, 'build', 'output.json')} is not an Application object`);
+    }
+    const solution = await readSolution({ solutionDir });
+    const built = pruneBuilt({ built: toComparable(output), entries: solution.entries, gaps });
+    const legacy = toComparable(assembleLegacy(prune({ entries: solution.entries, gaps })));
+    const seen = new Set();
+    const mismatches = [];
+    for (const [kind, id] of [...entityKeys(legacy), ...entityKeys(built)]) {
+        const key = JSON.stringify([kind, id]);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const { equal, differingKeys } = verifyEntity({ kind, id, built, legacy });
+        if (!equal)
+            mismatches.push({ kind, id, differingKeys });
+    }
+    mismatches.sort((a, b) => ENTITY_KINDS.indexOf(a.kind) - ENTITY_KINDS.indexOf(b.kind) || compareText(a.id, b.id));
+    return { checked: seen.size, mismatches };
+}
+//# sourceMappingURL=migrate.js.map