@nyrra/prismantix-cli 0.0.4-next.23 → 0.0.4-next.25

package/dist/foundry-import/emit.js

@@ -4,6 +4,8 @@ import { isRecord } from "./utils.js";
 export function emitFoundryImportFiles(result, options = {}) {
     const ontologyName = options.ontologyName ?? "ImportedFoundryOntology";
     return [
+        emitPackageJson(ontologyName),
+        emitTsconfig(),
         emitIndex(ontologyName),
         emitOntologyEntrypoint(ontologyName),
         { path: "objects.mts", content: emitObjects(result, ontologyName) },
@@ -22,6 +24,45 @@ export function emitFoundryImportFiles(result, options = {}) {
         { path: "diagnostics.md", content: emitDiagnosticsMarkdown(result) },
     ];
 }
+function emitPackageJson(ontologyName) {
+    return {
+        path: "package.json",
+        content: `${JSON.stringify({
+            dependencies: {
+                "@osdk/maker": "0.44.0",
+            },
+            devDependencies: {
+                typescript: "^5.9.3",
+            },
+            name: `@imported-ontology/${packageSlug(ontologyName)}`,
+            private: true,
+            scripts: {
+                typecheck: "tsc -p tsconfig.json --noEmit",
+            },
+            type: "module",
+            version: "0.0.0",
+        }, null, 2)}\n`,
+    };
+}
+function emitTsconfig() {
+    return {
+        path: "tsconfig.json",
+        content: `${JSON.stringify({
+            compilerOptions: {
+                declaration: true,
+                module: "NodeNext",
+                moduleResolution: "NodeNext",
+                noEmitOnError: true,
+                outDir: "dist",
+                rootDir: ".",
+                skipLibCheck: true,
+                strict: true,
+                target: "ES2022",
+            },
+            include: ["*.mts"],
+        }, null, 2)}\n`,
+    };
+}
 function emitIndex(ontologyName) {
     return {
         path: "index.mts",
@@ -55,6 +96,7 @@ function emitObjects(result, ontologyName) {
     return [
         header(ontologyName),
         `import { defineObject } from "@osdk/maker";`,
+        ...objectInterfaceImports(result),
         "",
         body,
         "",
@@ -62,6 +104,12 @@ function emitObjects(result, ontologyName) {
         "",
     ].join("\n");
 }
+function objectInterfaceImports(result) {
+    const interfaceNames = Array.from(new Set(result.objects.flatMap((object) => object.interfaceImplementations.map((implementation) => implementation.interfaceVariableName))));
+    return interfaceNames.length === 0
+        ? []
+        : [`import { ${interfaceNames.join(", ")} } from "./interfaces.mjs";`];
+}
 function emitObject(object) {
     const properties = object.properties.map(emitObjectProperty).join(",\n");
     return [
@@ -70,6 +118,9 @@ function emitObject(object) {
             apiName: object.apiName.sanitized,
             description: object.description,
             displayName: object.displayName,
+            implementsInterfaces: object.interfaceImplementations.length > 0
+                ? raw(`[\n${object.interfaceImplementations.map(emitObjectInterfaceImplementation).join(",\n")}\n\t]`)
+                : undefined,
             pluralDisplayName: object.pluralDisplayName,
             primaryKeyPropertyApiName: object.primaryKeyPropertyApiName,
             properties: raw(`{\n${properties}\n\t}`),
@@ -78,6 +129,12 @@ function emitObject(object) {
         }, 0)});`,
     ].join("\n");
 }
+function emitObjectInterfaceImplementation(implementation) {
+    return `\t\t{\n\t\t\timplements: ${implementation.interfaceVariableName},\n\t\t\tpropertyMapping: ${objectLiteral(implementation.propertyMappings.map((mapping) => ({
+        interfaceProperty: mapping.interfacePropertyApiName,
+        mapsTo: mapping.objectPropertyApiName,
+    })), 3)}\n\t\t}`;
+}
 function emitObjectProperty(property) {
     return `\t\t${safePropertyKey(property.apiName.sanitized)}: ${objectLiteral({
         array: property.array || undefined,
@@ -142,17 +199,56 @@ function emitSharedProperty(property) {
     ].join("\n");
 }
 function emitInterfaces(result, ontologyName) {
-    const body = result.interfaces.map(emitInterface).join("\n\n");
+    const interfaces = orderedInterfacesForEmit(result.interfaces);
+    const body = interfaces.map(emitInterface).join("\n\n");
+    const links = interfaces.flatMap(emitInterfaceLinks).join("\n\n");
     return [
         header(ontologyName),
-        `import { defineInterface } from "@osdk/maker";`,
+        `import { defineInterface, defineInterfaceLinkConstraint } from "@osdk/maker";`,
+        ...interfaceSharedPropertyImports(result),
         "",
         body,
+        links ? `\n${links}` : "",
         "",
-        `export const INTERFACES = [${result.interfaces.map((interfaceType) => interfaceType.variableName).join(", ")}] as const;`,
+        `export const INTERFACES = [${interfaces.map((interfaceType) => interfaceType.variableName).join(", ")}] as const;`,
         "",
     ].join("\n");
 }
+function interfaceSharedPropertyImports(result) {
+    const sharedPropertyNames = Array.from(new Set(result.interfaces.flatMap((interfaceType) => interfaceType.properties.flatMap((property) => property.sharedPropertyVariableName
+        ? [property.sharedPropertyVariableName]
+        : []))));
+    return sharedPropertyNames.length === 0
+        ? []
+        : [
+            `import { ${sharedPropertyNames.join(", ")} } from "./sharedProperties.mjs";`,
+        ];
+}
+function orderedInterfacesForEmit(interfaces) {
+    const byApiName = new Map(interfaces.map((interfaceType) => [
+        interfaceType.apiName.sanitized,
+        interfaceType,
+    ]));
+    const emitted = new Set();
+    const ordered = [];
+    const visit = (interfaceType) => {
+        if (emitted.has(interfaceType.apiName.sanitized)) {
+            return;
+        }
+        emitted.add(interfaceType.apiName.sanitized);
+        for (const parent of interfaceType.extendsInterfaces) {
+            const parentInterface = byApiName.get(parent.apiName.sanitized);
+            if (parentInterface) {
+                visit(parentInterface);
+            }
+        }
+        ordered.push(interfaceType);
+    };
+    for (const interfaceType of interfaces) {
+        visit(interfaceType);
+    }
+    return ordered;
+}
 function emitInterface(interfaceType) {
     return [
         entityComment(interfaceType.apiName, interfaceType.rid),
@@ -160,6 +256,10 @@ function emitInterface(interfaceType) {
             apiName: interfaceType.apiName.sanitized,
             description: interfaceType.description,
             displayName: interfaceType.displayName,
+            extends: emitInterfaceExtends(interfaceType),
+            properties: interfaceType.properties.length > 0
+                ? raw(`{\n${interfaceType.properties.map(emitInterfaceProperty).join(",\n")}\n\t}`)
+                : undefined,
             searchable: interfaceType.searchable,
             status: interfaceType.status
                 ? { type: interfaceType.status }
@@ -167,14 +267,74 @@ function emitInterface(interfaceType) {
         }, 0)});`,
     ].join("\n");
 }
+function emitInterfaceExtends(interfaceType) {
+    if (interfaceType.extendsInterfaces.length === 0) {
+        return undefined;
+    }
+    const [firstReference] = interfaceType.extendsInterfaces;
+    return raw(interfaceType.extendsInterfaces.length === 1 && firstReference
+        ? firstReference.variableName
+        : `[${interfaceType.extendsInterfaces.map((reference) => reference.variableName).join(", ")}]`);
+}
+function emitInterfaceProperty(property) {
+    const value = property.sharedPropertyVariableName
+        ? objectLiteral(raw(`{ sharedPropertyType: ${property.sharedPropertyVariableName}, required: ${property.required ? "true" : "false"} }`), 2)
+        : objectLiteral({
+            displayName: property.displayName,
+            required: property.required || undefined,
+            type: property.type,
+        }, 2);
+    return `\t\t${safePropertyKey(property.apiName.sanitized)}: ${value}`;
+}
+function emitInterfaceLinks(interfaceType) {
+    return interfaceType.links.map((link) => `defineInterfaceLinkConstraint(${objectLiteral({
+        apiName: link.apiName.sanitized,
+        description: link.description,
+        displayName: link.displayName,
+        from: raw(interfaceType.variableName),
+        required: link.required,
+        ...(link.cardinality === "MANY"
+            ? { toMany: raw(link.targetVariableName) }
+            : { toOne: raw(link.targetVariableName) }),
+    }, 0)});`);
+}
 function emitActions(result, ontologyName) {
+    const body = result.actions.map(emitAction).join("\n\n");
     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;`,
+        `import { defineAction } from "@osdk/maker";`,
+        "",
+        body,
+        "",
+        `export const ACTIONS = [${result.actions.map((action) => action.variableName).join(", ")}] as const;`,
         "",
     ].join("\n");
 }
+function emitAction(action) {
+    return [
+        entityComment(action.apiName, undefined),
+        `export const ${action.variableName} = defineAction(${objectLiteral({
+            apiName: action.apiName.sanitized,
+            displayName: action.displayName,
+            parameters: action.parameters.map(emitActionParameter),
+            parameterOrdering: action.parameters.map((parameter) => parameter.id.sanitized),
+            rules: action.rules,
+            status: action.status ?? "active",
+        }, 0)});`,
+    ].join("\n");
+}
+function emitActionParameter(parameter) {
+    return {
+        description: parameter.description,
+        displayName: parameter.displayName,
+        id: parameter.id.sanitized,
+        type: parameter.type,
+        validation: {
+            allowedValues: parameter.validationAllowedValues,
+            required: parameter.required,
+        },
+    };
+}
 function emitTypeGroups(result, ontologyName) {
     return [
         header(ontologyName),
@@ -261,3 +421,10 @@ function header(ontologyName) {
         `// Source ontology: ${ontologyName}. Review diagnostics before treating this as hand-authored OAC.`,
     ].join("\n");
 }
+function packageSlug(value) {
+    return (value
+        .toLowerCase()
+        .match(/[a-z0-9]+/g)
+        ?.join("-")
+        .slice(0, 100) || "imported-foundry-ontology");
+}

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

@@ -1,3 +1,12 @@
-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;
+import type { ConversionDiagnostic, FoundryInterface, NormalizedInterface, NormalizedSharedProperty } from "./types.js";
+interface InterfaceNormalizationContext {
+    readonly diagnostics: ConversionDiagnostic[];
+    readonly interfaceNameAllocator: (name: string) => string;
+    readonly sharedPropertiesByOriginalApiName: ReadonlyMap<string, NormalizedSharedProperty>;
+    readonly sharedPropertiesByRid: ReadonlyMap<string, NormalizedSharedProperty>;
+    readonly variableNameAllocator: (name: string) => string;
+}
+export declare function normalizeInterface(interfaceType: FoundryInterface, interfaceIndex: number, context: InterfaceNormalizationContext): NormalizedInterface;
+export declare function addInterfaceReferences(interfaceType: FoundryInterface, normalized: NormalizedInterface, interfaceIndex: number, interfacesByApiName: ReadonlyMap<string, NormalizedInterface>, diagnostics: ConversionDiagnostic[]): NormalizedInterface;
+export {};
 //# sourceMappingURL=interfaces.d.ts.map

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

@@ -1 +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,CA0CrB"}
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/foundry-import/interfaces.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACX,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EACxB,MAAM,YAAY,CAAC;AAQpB,UAAU,6BAA6B;IACtC,QAAQ,CAAC,WAAW,EAAE,oBAAoB,EAAE,CAAC;IAC7C,QAAQ,CAAC,sBAAsB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC1D,QAAQ,CAAC,iCAAiC,EAAE,WAAW,CACtD,MAAM,EACN,wBAAwB,CACxB,CAAC;IACF,QAAQ,CAAC,qBAAqB,EAAE,WAAW,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;IAC9E,QAAQ,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACzD;AAOD,wBAAgB,kBAAkB,CACjC,aAAa,EAAE,gBAAgB,EAC/B,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,6BAA6B,GACpC,mBAAmB,CA2CrB;AAED,wBAAgB,sBAAsB,CACrC,aAAa,EAAE,gBAAgB,EAC/B,UAAU,EAAE,mBAAmB,EAC/B,cAAc,EAAE,MAAM,EACtB,mBAAmB,EAAE,WAAW,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAC7D,WAAW,EAAE,oBAAoB,EAAE,GACjC,mBAAmB,CAkBrB"}

package/dist/foundry-import/interfaces.js

@@ -1,43 +1,151 @@
-import { addSanitizationDiagnostic, sanitizeApiName, toPascalCase, } from "./names.js";
+import { addSanitizationDiagnostic, createNameAllocator, sanitizeApiName, toPascalCase, } from "./names.js";
+import { mapPropertyType } from "./property-types.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);
+export function normalizeInterface(interfaceType, interfaceIndex, context) {
+    const originalApiName = requiredString(interfaceType.apiName, `$.interfaces[${interfaceIndex}].apiName`, context.diagnostics, `Interface${interfaceIndex + 1}`);
+    const sanitizedApiName = context.interfaceNameAllocator(sanitizeApiName(originalApiName, "api"));
+    addSanitizationDiagnostic(context.diagnostics, `$.interfaces[${interfaceIndex}].apiName`, originalApiName, sanitizedApiName);
     return {
         apiName: { original: originalApiName, sanitized: sanitizedApiName },
         description: normalizeDescription(interfaceType.displayMetadata?.description),
         displayName: displayNameFor(interfaceType.displayMetadata, sanitizedApiName),
+        extendsInterfaces: [],
+        links: [],
+        properties: normalizeInterfaceProperties(interfaceType, interfaceIndex, context),
         rid: interfaceType.rid,
         searchable: interfaceType.searchable ?? false,
-        status: normalizeStatus(interfaceType.status, `$.interfaces[${interfaceIndex}].status`, diagnostics),
-        variableName: variableNameAllocator(`${toPascalCase(sanitizedApiName)}Interface`),
+        status: normalizeStatus(interfaceType.status, `$.interfaces[${interfaceIndex}].status`, context.diagnostics),
+        variableName: context.variableNameAllocator(`${toPascalCase(sanitizedApiName)}Interface`),
     };
 }
-function addInterfaceDiagnostics(interfaceType, interfaceIndex, apiName, diagnostics) {
-    addInterfaceLinksDiagnostic(interfaceType, interfaceIndex, apiName, diagnostics);
-    addInterfacePropertiesDiagnostic(interfaceType, interfaceIndex, apiName, diagnostics);
+export function addInterfaceReferences(interfaceType, normalized, interfaceIndex, interfacesByApiName, diagnostics) {
+    return {
+        ...normalized,
+        extendsInterfaces: normalizeInterfaceExtends(interfaceType, normalized, interfaceIndex, interfacesByApiName, diagnostics),
+        links: normalizeInterfaceLinks(interfaceType, normalized, interfaceIndex, interfacesByApiName, diagnostics),
+    };
+}
+function normalizeInterfaceProperties(interfaceType, interfaceIndex, context) {
+    const propertyNameAllocator = createNameAllocator();
+    return (interfaceType.properties ?? []).map((property, propertyIndex) => normalizeInterfaceProperty(property, propertyIndex, interfaceIndex, propertyNameAllocator, context));
+}
+function normalizeInterfaceProperty(property, propertyIndex, interfaceIndex, propertyNameAllocator, context) {
+    const path = `$.interfaces[${interfaceIndex}].properties[${propertyIndex}]`;
+    const original = requiredString(property.apiName, `${path}.apiName`, context.diagnostics, `property${propertyIndex + 1}`);
+    const sharedProperty = interfaceSharedProperty(property, original, context);
+    return sharedProperty
+        ? sharedInterfaceProperty(property, sharedProperty)
+        : inlineInterfaceProperty(property, original, path, propertyNameAllocator, context);
+}
+function interfaceSharedProperty(property, original, context) {
+    return ((property.sharedPropertyRid
+        ? context.sharedPropertiesByRid.get(property.sharedPropertyRid)
+        : undefined) ??
+        context.sharedPropertiesByOriginalApiName.get(original) ??
+        context.sharedPropertiesByOriginalApiName.get(sanitizeApiName(original, "api")));
+}
+function sharedInterfaceProperty(property, sharedProperty) {
+    return {
+        apiName: sharedProperty.apiName,
+        displayName: property.displayName ?? sharedProperty.apiName.sanitized,
+        required: property.required ?? false,
+        sharedPropertyVariableName: sharedProperty.variableName,
+        type: undefined,
+    };
+}
+function inlineInterfaceProperty(property, original, path, propertyNameAllocator, context) {
+    const apiName = normalizeInterfacePropertyApiName(original, path, propertyNameAllocator, context.diagnostics);
+    return {
+        apiName,
+        displayName: property.displayName ?? apiName.sanitized,
+        required: property.required ?? false,
+        sharedPropertyVariableName: undefined,
+        type: mapPropertyType(property.type, `${path}.type`, context.diagnostics)
+            .type,
+    };
 }
-function addInterfaceLinksDiagnostic(interfaceType, interfaceIndex, apiName, diagnostics) {
-    if ((interfaceType.links?.length ?? 0) === 0) {
-        return;
+function normalizeInterfacePropertyApiName(original, path, nameAllocator, diagnostics) {
+    const sanitized = nameAllocator(sanitizeApiName(original, "api"));
+    addSanitizationDiagnostic(diagnostics, `${path}.apiName`, original, sanitized);
+    return { original, sanitized };
+}
+function normalizeInterfaceExtends(interfaceType, normalized, interfaceIndex, interfacesByApiName, diagnostics) {
+    return (interfaceType.extendsInterfaces ?? []).flatMap((apiName, index) => {
+        const target = interfacesByApiName.get(apiName);
+        if (target) {
+            return [
+                {
+                    apiName: target.apiName,
+                    variableName: target.variableName,
+                },
+            ];
+        }
+        diagnostics.push({
+            code: "skipped.interfaceExtends",
+            message: `Interface ${normalized.apiName.original} extends missing interface ${apiName}; extension was not emitted.`,
+            path: `$.interfaces[${interfaceIndex}].extendsInterfaces[${index}]`,
+            severity: "warning",
+        });
+        return [];
+    });
+}
+function normalizeInterfaceLinks(interfaceType, normalized, interfaceIndex, interfacesByApiName, diagnostics) {
+    const linkNameAllocator = createNameAllocator();
+    return (interfaceType.links ?? []).flatMap((link, linkIndex) => normalizeInterfaceLink(link, linkIndex, normalized, interfaceIndex, linkNameAllocator, interfacesByApiName, diagnostics));
+}
+function normalizeInterfaceLink(link, linkIndex, normalized, interfaceIndex, linkNameAllocator, interfacesByApiName, diagnostics) {
+    const path = `$.interfaces[${interfaceIndex}].links[${linkIndex}]`;
+    const target = resolveInterfaceLinkTarget(link, linkIndex, normalized, path, interfacesByApiName, diagnostics);
+    if (!target) {
+        return [];
+    }
+    const original = requiredString(link.apiName, `${path}.apiName`, diagnostics, `link${linkIndex + 1}`);
+    const sanitized = linkNameAllocator(sanitizeApiName(original, "api"));
+    addSanitizationDiagnostic(diagnostics, `${path}.apiName`, original, sanitized);
+    return [
+        {
+            apiName: { original, sanitized },
+            cardinality: interfaceLinkCardinality(link),
+            description: normalizeDescription(link.description),
+            displayName: link.displayName ?? sanitized,
+            required: link.required,
+            targetApiName: target.apiName,
+            targetVariableName: target.variableName,
+        },
+    ];
+}
+function resolveInterfaceLinkTarget(link, linkIndex, normalized, path, interfacesByApiName, diagnostics) {
+    if (unsupportedInterfaceLinkTarget(link)) {
+        addSkippedInterfaceLinkDiagnostic(link, linkIndex, normalized, path, diagnostics);
+        return undefined;
     }
+    const target = link.linkedEntityApiName
+        ? interfacesByApiName.get(link.linkedEntityApiName)
+        : undefined;
+    if (!target) {
+        addMissingInterfaceLinkTargetDiagnostic(link, linkIndex, normalized, path, diagnostics);
+    }
+    return target;
+}
+function unsupportedInterfaceLinkTarget(link) {
+    return Boolean(link.linkedEntityType && link.linkedEntityType !== "interfaceTypeApiName");
+}
+function addSkippedInterfaceLinkDiagnostic(link, linkIndex, normalized, path, diagnostics) {
     diagnostics.push({
-        code: "unsupported.interfaceLinks",
-        message: `Interface ${apiName} has interface links; emitted interface shell only.`,
-        path: `$.interfaces[${interfaceIndex}].links`,
+        code: "skipped.interfaceLinkTarget",
+        message: `Interface ${normalized.apiName.original} link ${link.apiName ?? linkIndex} targets ${link.linkedEntityType}; only interface targets are emitted.`,
+        path,
         severity: "warning",
     });
 }
-function addInterfacePropertiesDiagnostic(interfaceType, interfaceIndex, apiName, diagnostics) {
-    if ((interfaceType.properties?.length ?? 0) === 0) {
-        return;
-    }
+function addMissingInterfaceLinkTargetDiagnostic(link, linkIndex, normalized, path, diagnostics) {
     diagnostics.push({
-        code: "partial.interfaceProperties",
-        message: `Interface ${apiName} has properties; emitted interface shell only in this first pass.`,
-        path: `$.interfaces[${interfaceIndex}].properties`,
+        code: "skipped.interfaceLinkTarget",
+        message: `Interface ${normalized.apiName.original} link ${link.apiName ?? linkIndex} targets missing interface ${link.linkedEntityApiName ?? "unknown"}; link was not emitted.`,
+        path,
         severity: "warning",
     });
 }
+function interfaceLinkCardinality(link) {
+    return link.cardinality === "MANY" ? "MANY" : "SINGLE";
+}

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

@@ -2,6 +2,7 @@ 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 sanitizeActionApiName(name: string): 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;

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

@@ -1 +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"}
+{"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;AAiBjE,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,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAmB1D;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"}

package/dist/foundry-import/names.js

@@ -1,5 +1,6 @@
 const objectApiNamePattern = /^[a-zA-Z][a-zA-Z0-9]{0,99}$/;
 const apiNamePattern = /^[a-zA-Z][a-zA-Z0-9_]{0,99}$/;
+const actionApiNamePattern = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 const reservedApiNames = new Set([
     "ontology",
     "object",
@@ -29,6 +30,23 @@ export function sanitizeApiName(name, mode) {
     }
     return prefixedApiName(candidate, mode);
 }
+export function sanitizeActionApiName(name) {
+    const words = name
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/([A-Z])([A-Z][a-z])/g, "$1 $2")
+        .match(/[a-zA-Z0-9]+/g)
+        ?.map((word) => word.toLowerCase())
+        .filter((word) => word.length > 0) ?? ["imported"];
+    const candidate = words
+        .join("-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 100);
+    if (actionApiNamePattern.test(candidate)) {
+        return candidate;
+    }
+    const fallback = `imported-${candidate.replace(/^[^a-z0-9]+/, "")}`.slice(0, 100);
+    return actionApiNamePattern.test(fallback) ? fallback : "imported-action";
+}
 export function createNameAllocator() {
     const seen = new Map();
     return (name) => {

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

@@ -1,6 +1,7 @@
-import type { ConversionDiagnostic, FoundryObjectType, NormalizedObject } from "./types.js";
+import type { ConversionDiagnostic, FoundryObjectType, NormalizedInterface, NormalizedObject } from "./types.js";
 interface ObjectNormalizationContext {
     readonly diagnostics: ConversionDiagnostic[];
+    readonly interfacesByApiName: ReadonlyMap<string, NormalizedInterface>;
     readonly objectNameAllocator: (name: string) => string;
     readonly variableNameAllocator: (name: string) => string;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/foundry-import/objects.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACX,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,MAAM,YAAY,CAAC;AAQpB,UAAU,0BAA0B;IACnC,QAAQ,CAAC,WAAW,EAAE,oBAAoB,EAAE,CAAC;IAC7C,QAAQ,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACvD,QAAQ,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACzD;AAED,wBAAgB,eAAe,CAC9B,UAAU,EAAE,iBAAiB,EAC7B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,0BAA0B,GACjC,gBAAgB,CAqDlB"}
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/foundry-import/objects.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACX,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,MAAM,YAAY,CAAC;AAQpB,UAAU,0BAA0B;IACnC,QAAQ,CAAC,WAAW,EAAE,oBAAoB,EAAE,CAAC;IAC7C,QAAQ,CAAC,mBAAmB,EAAE,WAAW,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACvE,QAAQ,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACvD,QAAQ,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACzD;AAED,wBAAgB,eAAe,CAC9B,UAAU,EAAE,iBAAiB,EAC7B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,0BAA0B,GACjC,gBAAgB,CA6DlB"}

package/dist/foundry-import/objects.js

@@ -13,6 +13,8 @@ export function normalizeObject(objectType, objectIndex, context) {
         apiName,
         description: objectDescription(objectType),
         displayName: objectDisplayName(objectType, apiName.sanitized),
+        id: objectType.id,
+        interfaceImplementations: normalizeInterfaceImplementations(objectType, objectIndex, apiName.original, properties, context),
         pluralDisplayName: pluralDisplayNameFor(objectType, apiName.sanitized),
         primaryKeyPropertyApiName: keyPropertyApiName(keys.primaryKeyProperty, fallbackProperty),
         properties,
@@ -57,20 +59,100 @@ function normalizeObjectProperties(objectType, objectIndex, context) {
     return (objectType.properties ?? []).map((property, propertyIndex) => normalizeProperty(property, `$.objectTypes[${objectIndex}].properties[${propertyIndex}]`, propertyNameAllocator, context.diagnostics));
 }
 function addObjectMetadataDiagnostics(objectType, objectIndex, apiName, diagnostics) {
-    addObjectInterfacesDiagnostic(objectType, objectIndex, apiName, diagnostics);
     addObjectTypeGroupsDiagnostic(objectType, objectIndex, apiName, diagnostics);
 }
-function addObjectInterfacesDiagnostic(objectType, objectIndex, apiName, diagnostics) {
-    if ((objectType.interfaces?.length ?? 0) === 0) {
-        return;
-    }
-    diagnostics.push({
-        code: "partial.objectInterfaces",
-        message: `Object ${apiName} implements interfaces; interface implementation bindings are not emitted in this first pass.`,
-        path: `$.objectTypes[${objectIndex}].interfaces`,
-        severity: "warning",
+function normalizeInterfaceImplementations(objectType, objectIndex, apiName, properties, context) {
+    const implementations = objectInterfaceImplementations(objectType);
+    const propertiesByApiName = indexPropertiesByApiName(properties);
+    return implementations.flatMap((implementation, implementationIndex) => {
+        const path = `$.objectTypes[${objectIndex}].interfaces[${implementationIndex}]`;
+        const interfaceType = context.interfacesByApiName.get(implementation.interfaceApiName);
+        if (!interfaceType) {
+            context.diagnostics.push({
+                code: "skipped.objectInterfaceImplementation",
+                message: `Object ${apiName} implements missing interface ${implementation.interfaceApiName}; implementation was not emitted.`,
+                path,
+                severity: "warning",
+            });
+            return [];
+        }
+        const mappedProperties = implementation.propertyMappings.flatMap((mapping, mappingIndex) => normalizeInterfacePropertyMapping(mapping, mappingIndex, path, apiName, interfaceType, propertiesByApiName, context.diagnostics));
+        const missingProperties = flattenedInterfaceProperties(interfaceType, context.interfacesByApiName).filter((property) => !mappedProperties.some((mapping) => mapping.interfacePropertyApiName === property.apiName.sanitized));
+        if (missingProperties.length > 0) {
+            context.diagnostics.push({
+                code: "skipped.objectInterfaceImplementation",
+                message: `Object ${apiName} implementation of ${interfaceType.apiName.original} is missing mappings for ${missingProperties.map((property) => property.apiName.original).join(", ")}; implementation was not emitted.`,
+                path,
+                severity: "warning",
+            });
+            return [];
+        }
+        return [
+            {
+                interfaceApiName: interfaceType.apiName,
+                interfaceVariableName: interfaceType.variableName,
+                propertyMappings: mappedProperties,
+            },
+        ];
     });
 }
+function objectInterfaceImplementations(objectType) {
+    const explicit = objectType.interfaceImplementations ?? [];
+    if (explicit.length > 0) {
+        return explicit;
+    }
+    return (objectType.interfaces ?? []).map((interfaceApiName) => ({
+        interfaceApiName,
+        propertyMappings: [],
+    }));
+}
+function indexPropertiesByApiName(properties) {
+    const index = new Map();
+    for (const property of properties) {
+        index.set(property.originalId, property);
+        index.set(property.apiName.original, property);
+        index.set(property.apiName.sanitized, property);
+    }
+    return index;
+}
+function normalizeInterfacePropertyMapping(mapping, mappingIndex, path, objectApiName, interfaceType, propertiesByApiName, diagnostics) {
+    const interfaceProperty = interfacePropertyByApiName(interfaceType, mapping.interfacePropertyApiName);
+    const objectProperty = propertiesByApiName.get(mapping.objectPropertyApiName);
+    if (!interfaceProperty || !objectProperty) {
+        diagnostics.push({
+            code: "skipped.objectInterfacePropertyMapping",
+            message: `Object ${objectApiName} has an unresolved interface mapping ${mapping.interfacePropertyApiName} -> ${mapping.objectPropertyApiName}.`,
+            path: `${path}.propertyMappings[${mappingIndex}]`,
+            severity: "warning",
+        });
+        return [];
+    }
+    return [
+        {
+            interfacePropertyApiName: interfaceProperty.apiName.sanitized,
+            objectPropertyApiName: objectProperty.apiName.sanitized,
+        },
+    ];
+}
+function interfacePropertyByApiName(interfaceType, apiName) {
+    return interfaceType.properties.find((property) => property.apiName.original === apiName ||
+        property.apiName.sanitized === apiName);
+}
+function flattenedInterfaceProperties(interfaceType, interfacesByApiName, seen = new Set()) {
+    if (seen.has(interfaceType.apiName.sanitized)) {
+        return interfaceType.properties;
+    }
+    seen.add(interfaceType.apiName.sanitized);
+    return [
+        ...interfaceType.extendsInterfaces.flatMap((reference) => {
+            const extended = interfacesByApiName.get(reference.apiName.original);
+            return extended
+                ? flattenedInterfaceProperties(extended, interfacesByApiName, seen)
+                : [];
+        }),
+        ...interfaceType.properties,
+    ];
+}
 function addObjectTypeGroupsDiagnostic(objectType, objectIndex, apiName, diagnostics) {
     if ((objectType.typeGroups?.length ?? 0) === 0) {
         return;

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

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/foundry-import/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGxE,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,oBAAoB,EAAE,GACjC,eAAe,CAejB"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/foundry-import/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,oBAAoB,EAYpB,eAAe,EACf,MAAM,YAAY,CAAC;AAOpB,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,oBAAoB,EAAE,GACjC,eAAe,CAkBjB"}