@nyrra/prismantix-cli 0.0.4-next.20 → 0.0.4-next.22

package/README.md

@@ -40,3 +40,17 @@ npx -y @nyrra/prismantix-cli download \
 ```
 
 `--json` keeps stdout machine-readable. Progress and errors are written to stderr, and the API key is never printed.
+
+## Foundry Ontology Import
+
+Convert a downloaded Foundry ontology export JSON into best-effort Ontology-as-Code source:
+
+```sh
+npx -y @nyrra/prismantix-cli foundry import \
+  --input ./ontology-export.json \
+  --output ./foundry-oac \
+  --ontology-name devcon \
+  --json
+```
+
+The command writes generated `.mts` files plus `diagnostics.json` and `diagnostics.md`. The emitted source targets upstream `@osdk/maker` OAC, not PrismantiX's local `@nyrra/maker` DSL. Dotted or hyphenated Foundry API names are normalized into maker-compatible identifiers and reported in diagnostics.

package/dist/commands/foundry/import.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "@oclif/core";
+export default class FoundryImport extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "ontology-name": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        validate: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private fail;
+    private printProgress;
+    private printSummary;
+}
+//# sourceMappingURL=import.d.ts.map

package/dist/commands/foundry/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../src/commands/foundry/import.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAS,MAAM,aAAa,CAAC;AAQ7C,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,OAAO;IACjD,OAAgB,WAAW,SACyD;IAEpF,OAAgB,QAAQ,WAGtB;IAEF,OAAgB,KAAK;;;;;;MAmBnB;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IA2BjC,OAAO,CAAC,IAAI;IAeZ,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,YAAY;CAqBpB"}

package/dist/commands/foundry/import.js

@@ -0,0 +1,94 @@
+import { Command, Flags } from "@oclif/core";
+import { toCliUserError } from "../../errors.js";
+import { runFoundryImportWorkflow, } from "../../foundry-import.js";
+export default class FoundryImport extends Command {
+    static description = "Convert a Foundry ontology export JSON into best-effort Ontology-as-Code source.";
+    static examples = [
+        "<%= config.bin %> foundry import --input ontology.json --output ./oac",
+        "<%= config.bin %> foundry import --input ontology.json --ontology-name devcon --json",
+    ];
+    static flags = {
+        input: Flags.string({
+            description: "Foundry ontology export JSON file.",
+            env: "PRISMANTIX_FOUNDRY_EXPORT",
+        }),
+        json: Flags.boolean({
+            description: "Print machine-readable JSON to stdout.",
+        }),
+        "ontology-name": Flags.string({
+            description: "Name to write into generated source file headers.",
+        }),
+        output: Flags.string({
+            description: "Output directory.",
+            env: "PRISMANTIX_OUTPUT_DIR",
+        }),
+        validate: Flags.boolean({
+            description: "Compile generated source and run upstream @osdk/maker OntologyIr conversion.",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(FoundryImport);
+        try {
+            const result = await runFoundryImportWorkflow({
+                input: flags.input,
+                ontologyName: flags["ontology-name"],
+                outputDir: flags.output,
+                validate: flags.validate,
+            }, {
+                onEvent: (event) => this.printProgress(event),
+            });
+            if (flags.json) {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            this.printSummary(result);
+        }
+        catch (error) {
+            this.fail(toCliUserError(error), flags.json);
+        }
+    }
+    fail(error, json) {
+        if (json) {
+            this.logToStderr(JSON.stringify({
+                code: error.code,
+                error: error.message,
+                ok: false,
+            }));
+            this.exit(error.exitCode);
+        }
+        this.error(error.message, { code: error.code, exit: error.exitCode });
+    }
+    printProgress(event) {
+        this.logToStderr(progressMessage(event));
+    }
+    printSummary(result) {
+        this.log(`Imported Foundry ontology ${result.ontologyName}`);
+        this.log(`Input: ${result.inputPath}`);
+        this.log(`Output: ${result.outputDir}`);
+        this.log(`Files: ${result.files.length}`);
+        this.log(`Objects: ${result.counts.objects}; relations: ${result.counts.relations}; actions: ${result.counts.actions}; interfaces: ${result.counts.interfaces}; shared properties: ${result.counts.sharedProperties}; type groups: ${result.counts.typeGroups}`);
+        this.log(`Diagnostics: ${result.diagnostics.total} total, ${result.diagnostics.warnings + result.diagnostics.errors} warnings/errors, ${result.diagnostics.info} info.`);
+        if (result.validation) {
+            this.log(`Validation: ${result.validation.makerPackage} ${result.validation.makerVersion} produced OntologyIr (${result.validation.ontologyIrBytes} bytes).`);
+        }
+        for (const file of result.files) {
+            this.log(`- ${file.relativePath}: ${file.path}`);
+        }
+    }
+}
+function progressMessage(event) {
+    if (event.type === "read") {
+        return `Reading Foundry export ${event.inputPath}.`;
+    }
+    return completionProgressMessage(event);
+}
+function completionProgressMessage(event) {
+    switch (event.type) {
+        case "converted":
+            return `Converted ${event.counts.objects} objects, ${event.counts.relations} relations, ${event.counts.actions} actions, ${event.counts.interfaces} interfaces, and ${event.counts.sharedProperties} shared properties.`;
+        case "validated":
+            return `Validated generated OAC with ${event.validation.makerPackage} ${event.validation.makerVersion}.`;
+        case "write-file":
+            return `Wrote ${event.file.relativePath}.`;
+    }
+}

package/dist/constants.d.ts

@@ -1,4 +1,5 @@
 export declare const DEFAULT_API_BASE_URL = "https://api.prismantix.com";
+export declare const DEFAULT_FOUNDRY_IMPORT_OUTPUT_ROOT = "prismantix-foundry-imports";
 export declare const DEFAULT_OUTPUT_ROOT = "prismantix-exports";
 export declare const DEFAULT_POLL_INTERVAL_MS = 1000;
 export declare const DEFAULT_TIMEOUT_MS = 120000;

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,+BAA+B,CAAC;AACjE,eAAO,MAAM,mBAAmB,uBAAuB,CAAC;AACxD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,eAAO,MAAM,kBAAkB,SAAU,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,+BAA+B,CAAC;AACjE,eAAO,MAAM,kCAAkC,+BAA+B,CAAC;AAC/E,eAAO,MAAM,mBAAmB,uBAAuB,CAAC;AACxD,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAC7C,eAAO,MAAM,kBAAkB,SAAU,CAAC"}

package/dist/constants.js

@@ -1,4 +1,5 @@
 export const DEFAULT_API_BASE_URL = "https://api.prismantix.com";
+export const DEFAULT_FOUNDRY_IMPORT_OUTPUT_ROOT = "prismantix-foundry-imports";
 export const DEFAULT_OUTPUT_ROOT = "prismantix-exports";
 export const DEFAULT_POLL_INTERVAL_MS = 1000;
 export const DEFAULT_TIMEOUT_MS = 120_000;

package/dist/foundry-import/actions.d.ts

@@ -0,0 +1,3 @@
+import type { ConversionDiagnostic, FoundryActionType, NormalizedAction } from "./types.js";
+export declare function normalizeAction(action: FoundryActionType, actionIndex: number, nameAllocator: (name: string) => string, diagnostics: ConversionDiagnostic[]): NormalizedAction;
+//# sourceMappingURL=actions.d.ts.map

package/dist/foundry-import/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/foundry-import/actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,YAAY,CAAC;AAGpB,wBAAgB,eAAe,CAC9B,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACvC,WAAW,EAAE,oBAAoB,EAAE,GACjC,gBAAgB,CAclB"}

package/dist/foundry-import/actions.js

@@ -0,0 +1,37 @@
+import { addSanitizationDiagnostic, sanitizeApiName } from "./names.js";
+import { displayNameFor, normalizeStatus, requiredString } from "./utils.js";
+export function normalizeAction(action, actionIndex, nameAllocator, diagnostics) {
+    const apiName = normalizeActionApiName(action, actionIndex, nameAllocator, diagnostics);
+    return {
+        apiName,
+        displayName: actionDisplayName(action, apiName.sanitized),
+        parameterCount: parameterCount(actionFormContent(action)),
+        ruleTypes: actionRuleTypes(action),
+        status: actionStatus(action),
+    };
+}
+function normalizeActionApiName(action, actionIndex, nameAllocator, diagnostics) {
+    const path = `$.actionTypes[${actionIndex}].metadata.apiName`;
+    const original = requiredString(action.metadata?.apiName, path, diagnostics, `action${actionIndex + 1}`);
+    const sanitized = nameAllocator(sanitizeApiName(original, "api"));
+    addSanitizationDiagnostic(diagnostics, path, original, sanitized);
+    return { original, sanitized };
+}
+function parameterCount(formContent) {
+    return formContent.filter((content) => content.type === "parameter").length;
+}
+function actionDisplayName(action, fallback) {
+    return displayNameFor(action.metadata?.displayMetadata, fallback);
+}
+function actionFormContent(action) {
+    return action.metadata?.formContentInOrder ?? [];
+}
+function actionRuleTypes(action) {
+    return actionRules(action).map((rule) => rule.type ?? "unknown");
+}
+function actionRules(action) {
+    return action.actionTypeLogic?.logic?.rules ?? [];
+}
+function actionStatus(action) {
+    return normalizeStatus(action.metadata?.status);
+}

package/dist/foundry-import/convert.d.ts

@@ -0,0 +1,3 @@
+import type { ConversionResult } from "./types.js";
+export declare function convertFoundryV2Export(input: unknown): ConversionResult;
+//# sourceMappingURL=convert.d.ts.map

package/dist/foundry-import/convert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/foundry-import/convert.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEX,gBAAgB,EAIhB,MAAM,YAAY,CAAC;AAGpB,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAqDvE"}

package/dist/foundry-import/convert.js

@@ -0,0 +1,47 @@
+import { normalizeAction } from "./actions.js";
+import { normalizeInterface } from "./interfaces.js";
+import { createNameAllocator } from "./names.js";
+import { normalizeObject } from "./objects.js";
+import { parseFoundryV2Export } from "./parse.js";
+import { normalizeSharedProperty } from "./properties.js";
+import { normalizeRelation } from "./relations.js";
+import { displayNameFor } from "./utils.js";
+export function convertFoundryV2Export(input) {
+    const diagnostics = [];
+    const foundryExport = parseFoundryV2Export(input, diagnostics);
+    const objectNameAllocator = createNameAllocator();
+    const generalNameAllocator = createNameAllocator();
+    const relationNameAllocator = createNameAllocator();
+    const variableNameAllocator = createNameAllocator();
+    const objects = foundryExport.objectTypes.map((objectType, objectIndex) => normalizeObject(objectType, objectIndex, {
+        diagnostics,
+        objectNameAllocator,
+        variableNameAllocator,
+    }));
+    const objectsByRid = indexObjectsByRid(objects);
+    return {
+        actions: foundryExport.actionTypes.map((action, actionIndex) => normalizeAction(action, actionIndex, generalNameAllocator, diagnostics)),
+        diagnostics,
+        interfaces: foundryExport.interfaces.map((interfaceType, interfaceIndex) => normalizeInterface(interfaceType, interfaceIndex, generalNameAllocator, variableNameAllocator, diagnostics)),
+        objects,
+        relations: foundryExport.relations.flatMap((relation, relationIndex) => normalizeRelation(relation, relationIndex, objectsByRid, relationNameAllocator, variableNameAllocator, diagnostics)),
+        sharedProperties: foundryExport.sharedProperties.map((sharedProperty, sharedPropertyIndex) => normalizeSharedProperty(sharedProperty, sharedPropertyIndex, generalNameAllocator, variableNameAllocator, diagnostics)),
+        sourceVersion: foundryExport.version,
+        typeGroups: foundryExport.typeGroups.map(normalizeTypeGroup),
+    };
+}
+function indexObjectsByRid(objects) {
+    const objectsByRid = new Map();
+    for (const object of objects) {
+        if (object.rid) {
+            objectsByRid.set(object.rid, object);
+        }
+    }
+    return objectsByRid;
+}
+function normalizeTypeGroup(typeGroup) {
+    return {
+        displayName: displayNameFor(typeGroup.displayMetadata, typeGroup.rid ?? "Type Group"),
+        rid: typeGroup.rid,
+    };
+}

package/dist/foundry-import/emit.d.ts

@@ -0,0 +1,3 @@
+import type { ConversionResult, EmitOptions, EmittedFile } from "./types.js";
+export declare function emitFoundryImportFiles(result: ConversionResult, options?: EmitOptions): readonly EmittedFile[];
+//# sourceMappingURL=emit.d.ts.map

package/dist/foundry-import/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/foundry-import/emit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEX,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,MAAM,YAAY,CAAC;AAGpB,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,WAAgB,GACvB,SAAS,WAAW,EAAE,CAoBxB"}

package/dist/foundry-import/emit.js

@@ -0,0 +1,263 @@
+import { entityComment, safePropertyKey } from "./names.js";
+import { isRaw, raw } from "./relations.js";
+import { isRecord } from "./utils.js";
+export function emitFoundryImportFiles(result, options = {}) {
+    const ontologyName = options.ontologyName ?? "ImportedFoundryOntology";
+    return [
+        emitIndex(ontologyName),
+        emitOntologyEntrypoint(ontologyName),
+        { path: "objects.mts", content: emitObjects(result, ontologyName) },
+        { path: "relations.mts", content: emitRelations(result, ontologyName) },
+        {
+            path: "sharedProperties.mts",
+            content: emitSharedProperties(result, ontologyName),
+        },
+        { path: "interfaces.mts", content: emitInterfaces(result, ontologyName) },
+        { path: "actions.mts", content: emitActions(result, ontologyName) },
+        { path: "typeGroups.mts", content: emitTypeGroups(result, ontologyName) },
+        {
+            path: "diagnostics.json",
+            content: `${JSON.stringify(result.diagnostics, null, 2)}\n`,
+        },
+        { path: "diagnostics.md", content: emitDiagnosticsMarkdown(result) },
+    ];
+}
+function emitIndex(ontologyName) {
+    return {
+        path: "index.mts",
+        content: [
+            header(ontologyName),
+            `export { ACTIONS } from "./actions.mjs";`,
+            `export { INTERFACES } from "./interfaces.mjs";`,
+            `export { OBJECTS } from "./objects.mjs";`,
+            `export { RELATIONS } from "./relations.mjs";`,
+            `export { SHARED_PROPERTIES } from "./sharedProperties.mjs";`,
+            `export { TYPE_GROUPS } from "./typeGroups.mjs";`,
+            "",
+        ].join("\n"),
+    };
+}
+function emitOntologyEntrypoint(ontologyName) {
+    return {
+        path: "ontology.mts",
+        content: [
+            header(ontologyName),
+            `import "./sharedProperties.mjs";`,
+            `import "./interfaces.mjs";`,
+            `import "./objects.mjs";`,
+            `import "./relations.mjs";`,
+            "",
+        ].join("\n"),
+    };
+}
+function emitObjects(result, ontologyName) {
+    const body = result.objects.map(emitObject).join("\n\n");
+    return [
+        header(ontologyName),
+        `import { defineObject } from "@osdk/maker";`,
+        "",
+        body,
+        "",
+        `export const OBJECTS = [${result.objects.map((object) => object.variableName).join(", ")}] as const;`,
+        "",
+    ].join("\n");
+}
+function emitObject(object) {
+    const properties = object.properties.map(emitObjectProperty).join(",\n");
+    return [
+        entityComment(object.apiName, object.rid),
+        `export const ${object.variableName} = defineObject(${objectLiteral({
+            apiName: object.apiName.sanitized,
+            description: object.description,
+            displayName: object.displayName,
+            pluralDisplayName: object.pluralDisplayName,
+            primaryKeyPropertyApiName: object.primaryKeyPropertyApiName,
+            properties: raw(`{\n${properties}\n\t}`),
+            status: object.status,
+            titlePropertyApiName: object.titlePropertyApiName,
+        }, 0)});`,
+    ].join("\n");
+}
+function emitObjectProperty(property) {
+    return `\t\t${safePropertyKey(property.apiName.sanitized)}: ${objectLiteral({
+        array: property.array || undefined,
+        description: property.description,
+        displayName: property.displayName,
+        editOnly: property.editOnly || undefined,
+        indexedForSearch: property.indexedForSearch || undefined,
+        nullability: property.nullability,
+        type: property.type,
+        visibility: property.visibility,
+    }, 2)}`;
+}
+function emitRelations(result, ontologyName) {
+    const body = result.relations.map(emitRelation).join("\n\n");
+    return [
+        header(ontologyName),
+        `import { defineLink } from "@osdk/maker";`,
+        ...relationObjectImports(result),
+        "",
+        body,
+        "",
+        `export const RELATIONS = [${result.relations.map((relation) => relation.variableName).join(", ")}] as const;`,
+        "",
+    ].join("\n");
+}
+function relationObjectImports(result) {
+    const objectNames = result.objects.map((object) => object.variableName);
+    return objectNames.length === 0
+        ? []
+        : [`import { ${objectNames.join(", ")} } from "./objects.mjs";`];
+}
+function emitRelation(relation) {
+    return [
+        entityComment(relation.apiName, relation.rid),
+        `export const ${relation.variableName} = defineLink(${objectLiteral(relation.definition, 0)});`,
+    ].join("\n");
+}
+function emitSharedProperties(result, ontologyName) {
+    const body = result.sharedProperties.map(emitSharedProperty).join("\n\n");
+    return [
+        header(ontologyName),
+        `import { defineSharedPropertyType } from "@osdk/maker";`,
+        "",
+        body,
+        "",
+        `export const SHARED_PROPERTIES = [${result.sharedProperties.map((property) => property.variableName).join(", ")}] as const;`,
+        "",
+    ].join("\n");
+}
+function emitSharedProperty(property) {
+    return [
+        entityComment(property.apiName, property.rid),
+        `export const ${property.variableName} = defineSharedPropertyType(${objectLiteral({
+            apiName: property.apiName.sanitized,
+            array: property.array || undefined,
+            description: property.description,
+            displayName: property.displayName,
+            nullability: property.nullability,
+            type: property.type,
+            visibility: property.visibility,
+        }, 0)});`,
+    ].join("\n");
+}
+function emitInterfaces(result, ontologyName) {
+    const body = result.interfaces.map(emitInterface).join("\n\n");
+    return [
+        header(ontologyName),
+        `import { defineInterface } from "@osdk/maker";`,
+        "",
+        body,
+        "",
+        `export const INTERFACES = [${result.interfaces.map((interfaceType) => interfaceType.variableName).join(", ")}] as const;`,
+        "",
+    ].join("\n");
+}
+function emitInterface(interfaceType) {
+    return [
+        entityComment(interfaceType.apiName, interfaceType.rid),
+        `export const ${interfaceType.variableName} = defineInterface(${objectLiteral({
+            apiName: interfaceType.apiName.sanitized,
+            description: interfaceType.description,
+            displayName: interfaceType.displayName,
+            searchable: interfaceType.searchable,
+            status: interfaceType.status
+                ? { type: interfaceType.status }
+                : undefined,
+        }, 0)});`,
+    ].join("\n");
+}
+function emitActions(result, ontologyName) {
+    return [
+        header(ontologyName),
+        "// Action forms and logic are summarized here. Full action-rule reconstruction is intentionally deferred.",
+        `export const ACTIONS = ${objectLiteral(result.actions, 0)} as const;`,
+        "",
+    ].join("\n");
+}
+function emitTypeGroups(result, ontologyName) {
+    return [
+        header(ontologyName),
+        "// Type groups are not an upstream maker construct in this first pass.",
+        `export const TYPE_GROUPS = ${objectLiteral(result.typeGroups, 0)} as const;`,
+        "",
+    ].join("\n");
+}
+function emitDiagnosticsMarkdown(result) {
+    return [
+        "# Foundry Import Diagnostics",
+        "",
+        `Source version: ${result.sourceVersion}`,
+        "",
+        "## Counts",
+        "",
+        `- Objects: ${result.objects.length}`,
+        `- Relations: ${result.relations.length}`,
+        `- Actions: ${result.actions.length}`,
+        `- Interfaces: ${result.interfaces.length}`,
+        `- Shared properties: ${result.sharedProperties.length}`,
+        `- Type groups: ${result.typeGroups.length}`,
+        "",
+        "## Diagnostic Summary",
+        "",
+        diagnosticSummary(result.diagnostics),
+        "",
+        "## Details",
+        "",
+        diagnosticDetails(result.diagnostics),
+        "",
+    ].join("\n");
+}
+function diagnosticSummary(diagnostics) {
+    const counts = new Map();
+    for (const diagnostic of diagnostics) {
+        counts.set(diagnostic.code, (counts.get(diagnostic.code) ?? 0) + 1);
+    }
+    const lines = Array.from(counts.entries())
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([code, count]) => `- ${code}: ${count}`);
+    return markdownLines(lines, "- No diagnostics.");
+}
+function diagnosticDetails(diagnostics) {
+    return markdownLines(diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code} at \`${diagnostic.path}\`: ${diagnostic.message}`), "- No diagnostics.");
+}
+function markdownLines(lines, fallback) {
+    return lines.length === 0 ? fallback : lines.join("\n");
+}
+function objectLiteral(value, indentLevel) {
+    if (isRaw(value)) {
+        return value.value;
+    }
+    if (Array.isArray(value)) {
+        return arrayLiteral(value, indentLevel);
+    }
+    if (isRecord(value)) {
+        return recordLiteral(value, indentLevel);
+    }
+    return JSON.stringify(value);
+}
+function arrayLiteral(value, indentLevel) {
+    if (value.length === 0) {
+        return "[]";
+    }
+    const indent = "\t".repeat(indentLevel);
+    const innerIndent = "\t".repeat(indentLevel + 1);
+    return `[\n${value.map((item) => `${innerIndent}${objectLiteral(item, indentLevel + 1)}`).join(",\n")}\n${indent}]`;
+}
+function recordLiteral(value, indentLevel) {
+    const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== undefined);
+    if (entries.length === 0) {
+        return "{}";
+    }
+    const indent = "\t".repeat(indentLevel);
+    const innerIndent = "\t".repeat(indentLevel + 1);
+    return `{\n${entries
+        .map(([key, entryValue]) => `${innerIndent}${safePropertyKey(key)}: ${objectLiteral(entryValue, indentLevel + 1)}`)
+        .join(",\n")}\n${indent}}`;
+}
+function header(ontologyName) {
+    return [
+        `// Generated by @nyrra/prismantix-cli foundry import.`,
+        `// Source ontology: ${ontologyName}. Review diagnostics before treating this as hand-authored OAC.`,
+    ].join("\n");
+}

package/dist/foundry-import/interfaces.d.ts

@@ -0,0 +1,3 @@
+import type { ConversionDiagnostic, FoundryInterface, NormalizedInterface } from "./types.js";
+export declare function normalizeInterface(interfaceType: FoundryInterface, interfaceIndex: number, nameAllocator: (name: string) => string, variableNameAllocator: (name: string) => string, diagnostics: ConversionDiagnostic[]): NormalizedInterface;
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/foundry-import/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/foundry-import/interfaces.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACX,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,MAAM,YAAY,CAAC;AAQpB,wBAAgB,kBAAkB,CACjC,aAAa,EAAE,gBAAgB,EAC/B,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACvC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAC/C,WAAW,EAAE,oBAAoB,EAAE,GACjC,mBAAmB,CAsCrB"}

package/dist/foundry-import/interfaces.js

@@ -0,0 +1,43 @@
+import { addSanitizationDiagnostic, sanitizeApiName, toPascalCase, } from "./names.js";
+import { displayNameFor, normalizeDescription, normalizeStatus, requiredString, } from "./utils.js";
+export function normalizeInterface(interfaceType, interfaceIndex, nameAllocator, variableNameAllocator, diagnostics) {
+    const originalApiName = requiredString(interfaceType.apiName, `$.interfaces[${interfaceIndex}].apiName`, diagnostics, `Interface${interfaceIndex + 1}`);
+    const sanitizedApiName = nameAllocator(sanitizeApiName(originalApiName, "api"));
+    addSanitizationDiagnostic(diagnostics, `$.interfaces[${interfaceIndex}].apiName`, originalApiName, sanitizedApiName);
+    addInterfaceDiagnostics(interfaceType, interfaceIndex, originalApiName, diagnostics);
+    return {
+        apiName: { original: originalApiName, sanitized: sanitizedApiName },
+        description: normalizeDescription(interfaceType.displayMetadata?.description),
+        displayName: displayNameFor(interfaceType.displayMetadata, sanitizedApiName),
+        rid: interfaceType.rid,
+        searchable: interfaceType.searchable ?? false,
+        status: normalizeStatus(interfaceType.status),
+        variableName: variableNameAllocator(`${toPascalCase(sanitizedApiName)}Interface`),
+    };
+}
+function addInterfaceDiagnostics(interfaceType, interfaceIndex, apiName, diagnostics) {
+    addInterfaceLinksDiagnostic(interfaceType, interfaceIndex, apiName, diagnostics);
+    addInterfacePropertiesDiagnostic(interfaceType, interfaceIndex, apiName, diagnostics);
+}
+function addInterfaceLinksDiagnostic(interfaceType, interfaceIndex, apiName, diagnostics) {
+    if ((interfaceType.links?.length ?? 0) === 0) {
+        return;
+    }
+    diagnostics.push({
+        code: "unsupported.interfaceLinks",
+        message: `Interface ${apiName} has interface links; emitted interface shell only.`,
+        path: `$.interfaces[${interfaceIndex}].links`,
+        severity: "warning",
+    });
+}
+function addInterfacePropertiesDiagnostic(interfaceType, interfaceIndex, apiName, diagnostics) {
+    if ((interfaceType.properties?.length ?? 0) === 0) {
+        return;
+    }
+    diagnostics.push({
+        code: "partial.interfaceProperties",
+        message: `Interface ${apiName} has properties; emitted interface shell only in this first pass.`,
+        path: `$.interfaces[${interfaceIndex}].properties`,
+        severity: "warning",
+    });
+}

package/dist/foundry-import/names.d.ts

@@ -0,0 +1,10 @@
+import type { ConversionDiagnostic, NamePair } from "./types.js";
+type ApiNameMode = "api" | "object";
+export declare function addSanitizationDiagnostic(diagnostics: ConversionDiagnostic[], path: string, original: string, sanitized: string): void;
+export declare function sanitizeApiName(name: string, mode: ApiNameMode): string;
+export declare function createNameAllocator(): (name: string) => string;
+export declare function entityComment(name: NamePair, rid: string | undefined): string;
+export declare function safePropertyKey(key: string): string;
+export declare function toPascalCase(value: string): string;
+export {};
+//# sourceMappingURL=names.d.ts.map

package/dist/foundry-import/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/foundry-import/names.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAgBjE,KAAK,WAAW,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEpC,wBAAgB,yBAAyB,CACxC,WAAW,EAAE,oBAAoB,EAAE,EACnC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GACf,IAAI,CAUN;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,MAAM,CAMvE;AAED,wBAAgB,mBAAmB,IAAI,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAO9D;AAQD,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAI7E;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGlD"}