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

package/README.md

@@ -43,7 +43,7 @@ npx -y @nyrra/prismantix-cli download \
 
 ## Foundry Ontology Import
 
-Convert a downloaded Foundry ontology export JSON into best-effort Ontology-as-Code source:
+Convert a downloaded Foundry ontology export JSON into an upstream OSDK Ontology-as-Code package:
 
 ```sh
 npx -y @nyrra/prismantix-cli foundry import \
@@ -53,4 +53,4 @@ npx -y @nyrra/prismantix-cli foundry import \
   --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.
+The command writes a package scaffold (`package.json`, `tsconfig.json`), generated `.mts` files, and `diagnostics.json` / `diagnostics.md`. The emitted source targets upstream `@osdk/maker` OAC, not PrismantiX's local `@nyrra/maker` DSL. Use `--validate` to compile the generated source, load it through `@osdk/maker`, and convert it through `@osdk/generator-converters.ontologyir` into full metadata. Dotted or hyphenated Foundry API names are normalized into maker-compatible identifiers and reported in diagnostics.

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

@@ -1,3 +1,10 @@
-import type { ConversionDiagnostic, FoundryActionType, NormalizedAction } from "./types.js";
-export declare function normalizeAction(action: FoundryActionType, actionIndex: number, nameAllocator: (name: string) => string, diagnostics: ConversionDiagnostic[]): NormalizedAction;
+import type { ConversionDiagnostic, FoundryActionType, NormalizedAction, NormalizedObject } from "./types.js";
+interface ActionNormalizationContext {
+    readonly actionNameAllocator: (name: string) => string;
+    readonly diagnostics: ConversionDiagnostic[];
+    readonly objectsByApiName: ReadonlyMap<string, NormalizedObject>;
+    readonly variableNameAllocator: (name: string) => string;
+}
+export declare function normalizeAction(action: FoundryActionType, actionIndex: number, context: ActionNormalizationContext): NormalizedAction | undefined;
+export {};
 //# sourceMappingURL=actions.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/foundry-import/actions.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACX,oBAAoB,EAIpB,iBAAiB,EAEjB,gBAAgB,EAEhB,gBAAgB,EAChB,MAAM,YAAY,CAAC;AASpB,UAAU,0BAA0B;IACnC,QAAQ,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACvD,QAAQ,CAAC,WAAW,EAAE,oBAAoB,EAAE,CAAC;IAC7C,QAAQ,CAAC,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACjE,QAAQ,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACzD;AAED,wBAAgB,eAAe,CAC9B,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,0BAA0B,GACjC,gBAAgB,GAAG,SAAS,CAiC9B"}

package/dist/foundry-import/actions.js

@@ -1,37 +1,454 @@
-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);
+import { addSanitizationDiagnostic, createNameAllocator, sanitizeActionApiName, sanitizeApiName, toPascalCase, } from "./names.js";
+import { displayNameFor, isRecord, normalizeDescription, normalizeStatus, requiredString, } from "./utils.js";
+export function normalizeAction(action, actionIndex, context) {
+    const apiName = normalizeActionApiName(action, actionIndex, context);
+    const parameterNameAllocator = createNameAllocator();
+    const parameters = actionFormParameters(action).map((parameter, index) => normalizeActionParameter(parameter, index, actionIndex, parameterNameAllocator, context));
+    const rules = normalizeActionRules(action, actionIndex, parameters, context);
+    if (rules.length === 0) {
+        context.diagnostics.push({
+            code: "skipped.actionRules",
+            message: `Action ${apiName.original} has no Marketplace-compatible object/interface rules; action was not emitted.`,
+            path: `$.actionTypes[${actionIndex}].actionTypeLogic.logic.rules`,
+            severity: "warning",
+        });
+        return undefined;
+    }
     return {
         apiName,
         displayName: actionDisplayName(action, apiName.sanitized),
-        parameterCount: parameterCount(actionFormContent(action)),
-        ruleTypes: actionRuleTypes(action),
-        status: actionStatus(action, actionIndex, diagnostics),
+        parameters,
+        ruleTypes: rules.map(ruleType),
+        rules,
+        status: actionStatus(action, actionIndex, context.diagnostics),
+        variableName: context.variableNameAllocator(`${toPascalCase(apiName.sanitized)}Action`),
     };
 }
-function normalizeActionApiName(action, actionIndex, nameAllocator, diagnostics) {
+function normalizeActionApiName(action, actionIndex, context) {
     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);
+    const original = requiredString(action.metadata?.apiName, path, context.diagnostics, `action-${actionIndex + 1}`);
+    const sanitized = context.actionNameAllocator(sanitizeActionApiName(original));
+    addSanitizationDiagnostic(context.diagnostics, path, original, sanitized);
     return { original, sanitized };
 }
-function parameterCount(formContent) {
-    return formContent.filter((content) => content.type === "parameter").length;
+function actionFormParameters(action) {
+    return (action.metadata?.formContentInOrder ?? []).flatMap((content) => content.type === "parameter" && content.parameter
+        ? [content.parameter]
+        : []);
 }
-function actionDisplayName(action, fallback) {
-    return displayNameFor(action.metadata?.displayMetadata, fallback);
+function normalizeActionParameter(parameter, parameterIndex, actionIndex, nameAllocator, context) {
+    const path = `$.actionTypes[${actionIndex}].metadata.formContentInOrder[${parameterIndex}].parameter`;
+    const original = requiredString(parameter.id, `${path}.id`, context.diagnostics, `parameter${parameterIndex + 1}`);
+    const sanitized = nameAllocator(sanitizeApiName(original, "api"));
+    addSanitizationDiagnostic(context.diagnostics, `${path}.id`, original, sanitized);
+    const mappedType = mapActionParameterType(parameter.type, `${path}.type`, context);
+    return {
+        description: normalizeDescription(parameter.displayMetadata?.description),
+        displayName: displayNameFor(parameter.displayMetadata, sanitized),
+        id: { original, sanitized },
+        required: parameter.required ?? inferParameterRequired(parameter),
+        type: mappedType.type,
+        validationAllowedValues: mappedType.allowedValues,
+    };
+}
+const actionParameterTypeHandlers = {
+    ARRAY: mapArrayActionParameterType,
+    OBJECT: mapObjectActionParameterType,
+    object: mapObjectActionParameterType,
+    objectReference: mapObjectActionParameterType,
+    objectReferenceList: mapObjectListActionParameterType,
+};
+function mapActionParameterType(baseType, path, context) {
+    return actionParameterTypeHandlerFor(baseType?.type)(baseType, path, context);
+}
+function actionParameterTypeHandlerFor(type) {
+    return type
+        ? (actionParameterTypeHandlers[type] ??
+            mapScalarOrUnknownActionParameterType)
+        : mapDefaultActionParameterType;
+}
+function mapDefaultActionParameterType() {
+    return scalarActionParameterType("string", "text");
+}
+function mapScalarOrUnknownActionParameterType(baseType, path, context) {
+    if (!baseType?.type) {
+        return mapDefaultActionParameterType();
+    }
+    const type = actionScalarType(baseType.type);
+    if (type) {
+        return scalarActionParameterType(type, allowedValuesFor(type, baseType));
+    }
+    context.diagnostics.push({
+        code: "coerced.unknownActionParameterType",
+        message: `Unknown action parameter type ${String(baseType.type)} emitted as string.`,
+        path,
+        severity: "warning",
+    });
+    return scalarActionParameterType("string", "text");
+}
+function mapArrayActionParameterType(baseType, path, context) {
+    const mapped = mapActionParameterType(baseType?.subType, `${path}.subType`, context);
+    if (typeof mapped.type === "string") {
+        return scalarActionParameterType(`${mapped.type}List`, mapped.allowedValues);
+    }
+    if (isObjectParameterType(mapped.type, "objectReference")) {
+        return {
+            allowedValues: { type: "objectQuery" },
+            type: {
+                objectReferenceList: mapped.type.objectReference,
+                type: "objectReferenceList",
+            },
+        };
+    }
+    context.diagnostics.push({
+        code: "coerced.unsupportedActionParameterListType",
+        message: "Unsupported complex action list parameter emitted as stringList.",
+        path,
+        severity: "warning",
+    });
+    return scalarActionParameterType("stringList", "text");
+}
+function mapObjectListActionParameterType(baseType, path, context) {
+    const mapped = mapObjectActionParameterType(baseType, path, context);
+    if (!isObjectParameterType(mapped.type, "objectReference")) {
+        return mapped;
+    }
+    return {
+        allowedValues: { type: "objectQuery" },
+        type: {
+            objectReferenceList: mapped.type.objectReference,
+            type: "objectReferenceList",
+        },
+    };
+}
+function mapObjectActionParameterType(baseType, path, context) {
+    const objectType = lookupActionParameterObjectType(baseType, context);
+    if (objectType) {
+        return objectReferenceActionParameterType(objectType);
+    }
+    addUnresolvedActionObjectParameterDiagnostic(baseType, path, context);
+    return scalarActionParameterType("string", "text");
+}
+function lookupActionParameterObjectType(baseType, context) {
+    const objectTypeApiName = baseType
+        ? objectTypeReferenceApiName(baseType)
+        : undefined;
+    return objectTypeApiName
+        ? context.objectsByApiName.get(objectTypeApiName)
+        : undefined;
+}
+function addUnresolvedActionObjectParameterDiagnostic(baseType, path, context) {
+    context.diagnostics.push({
+        code: "coerced.unresolvedActionObjectParameter",
+        message: `Action object parameter references missing object ${baseType ? (objectTypeReferenceApiName(baseType) ?? "unknown") : "unknown"}; emitted as string.`,
+        path,
+        severity: "warning",
+    });
+}
+function objectReferenceActionParameterType(objectType) {
+    return {
+        allowedValues: { type: "objectQuery" },
+        type: {
+            objectReference: { objectTypeId: objectType.apiName.sanitized },
+            type: "objectReference",
+        },
+    };
+}
+function scalarActionParameterType(type, allowedValues) {
+    return {
+        allowedValues: typeof allowedValues === "string"
+            ? { type: allowedValues }
+            : allowedValues,
+        type,
+    };
+}
+function actionScalarType(type) {
+    const scalarTypes = {
+        ATTACHMENT: "attachment",
+        BOOLEAN: "boolean",
+        DATE: "date",
+        DOUBLE: "double",
+        GEOHASH: "geohash",
+        GEOSHAPE: "geoshape",
+        INTEGER: "integer",
+        INTEGER_LIST: "integerList",
+        LONG: "long",
+        LONG_LIST: "longList",
+        MARKING: "marking",
+        MEDIA_REFERENCE: "mediaReference",
+        STRING: "string",
+        STRING_LIST: "stringList",
+        TIMESTAMP: "timestamp",
+        attachment: "attachment",
+        attachmentList: "attachmentList",
+        boolean: "boolean",
+        booleanList: "booleanList",
+        date: "date",
+        dateList: "dateList",
+        double: "double",
+        doubleList: "doubleList",
+        geohash: "geohash",
+        geohashList: "geohashList",
+        geopoint: "geohash",
+        geoshape: "geoshape",
+        geoshapeList: "geoshapeList",
+        integer: "integer",
+        integerList: "integerList",
+        long: "long",
+        longList: "longList",
+        marking: "marking",
+        markingList: "markingList",
+        mediaReference: "mediaReference",
+        mediaReferenceList: "mediaReferenceList",
+        string: "string",
+        stringList: "stringList",
+        timestamp: "timestamp",
+        timestampList: "timestampList",
+    };
+    return scalarTypes[type];
+}
+function allowedValuesFor(type, baseType) {
+    const scalarType = type.endsWith("List")
+        ? type.slice(0, -"List".length)
+        : type;
+    const allowedValues = {
+        attachment: "attachment",
+        boolean: "boolean",
+        date: "datetime",
+        double: "range",
+        geohash: "geohash",
+        geoshape: "geoshape",
+        integer: "range",
+        long: "range",
+        mediaReference: "mediaReference",
+        string: "text",
+        timestamp: "datetime",
+    };
+    return {
+        type: scalarType === "marking"
+            ? markingAllowedValuesType(baseType)
+            : (allowedValues[scalarType] ?? "text"),
+    };
+}
+function markingAllowedValuesType(baseType) {
+    return baseType.markingType === "CBAC" ? "cbacMarking" : "mandatoryMarking";
+}
+function objectTypeReferenceApiName(baseType) {
+    return objectTypeReferenceCandidates(baseType).find((candidate) => typeof candidate === "string");
+}
+function objectTypeReferenceCandidates(baseType) {
+    return [
+        stringField(baseType, "objectTypeApiName"),
+        stringField(baseType, "objectApiName"),
+        stringField(baseType, "objectTypeId"),
+        nestedObjectTypeReferenceApiName(baseType, "objectReference"),
+        nestedObjectTypeReferenceApiName(baseType, "objectReferenceList"),
+    ];
+}
+function nestedObjectTypeReferenceApiName(baseType, key) {
+    const reference = baseType[key];
+    return stringField(reference, "objectTypeId");
 }
-function actionFormContent(action) {
-    return action.metadata?.formContentInOrder ?? [];
+function normalizeActionRules(action, actionIndex, parameters, context) {
+    const operations = actionOperations(action);
+    return operations.flatMap((operation, operationIndex) => normalizeActionOperation(operation, operationIndex, actionIndex, parameters, context));
 }
-function actionRuleTypes(action) {
-    return actionRules(action).map((rule) => rule.type ?? "unknown");
+function actionOperations(action) {
+    const explicitOperations = action.operations ?? [];
+    return explicitOperations.length > 0
+        ? explicitOperations
+        : actionRules(action).map((rule) => ({
+            objectTypeApiName: actionRuleObjectTypeApiName(rule, action),
+            type: actionOperationType(rule.type),
+        }));
+}
+const actionOperationHandlers = {
+    createObject: createObjectOperationRules,
+    deleteObject: deleteObjectOperationRules,
+    modifyObject: modifyObjectOperationRules,
+};
+function normalizeActionOperation(operation, operationIndex, actionIndex, parameters, context) {
+    const path = `$.actionTypes[${actionIndex}].operations[${operationIndex}]`;
+    const objectType = actionOperationObjectType(operation, path, context);
+    const handler = actionOperationHandler(operation, path, context);
+    if (!objectType || !handler) {
+        return [];
+    }
+    return handler(objectType, parameters, path, context);
+}
+function actionOperationObjectType(operation, path, context) {
+    const objectType = lookupActionOperationObjectType(operation, context);
+    if (objectType) {
+        return objectType;
+    }
+    addSkippedActionOperationDiagnostic(`Action operation ${operation.type ?? "unknown"} references missing object ${operation.objectTypeApiName ?? "unknown"}; operation was not emitted.`, path, context);
+    return undefined;
+}
+function lookupActionOperationObjectType(operation, context) {
+    return operation.objectTypeApiName
+        ? context.objectsByApiName.get(operation.objectTypeApiName)
+        : undefined;
+}
+function actionOperationHandler(operation, path, context) {
+    const handler = operation.type
+        ? actionOperationHandlers[operation.type]
+        : undefined;
+    if (!handler) {
+        addSkippedActionOperationDiagnostic(`Action operation ${operation.type ?? "unknown"} is not emitted yet.`, path, context);
+    }
+    return handler;
+}
+function addSkippedActionOperationDiagnostic(message, path, context) {
+    context.diagnostics.push({
+        code: "skipped.actionOperation",
+        message,
+        path,
+        severity: "warning",
+    });
+}
+function createObjectOperationRules(objectType, parameters) {
+    return [createObjectRule(objectType, parameters)];
+}
+function modifyObjectOperationRules(objectType, parameters, path, context) {
+    const objectParameter = objectReferenceParameter(parameters, objectType);
+    if (!objectParameter) {
+        addMissingObjectParameterDiagnostic("Modify", objectType, path, context);
+        return [];
+    }
+    return [modifyObjectRule(objectParameter, objectType, parameters)];
+}
+function deleteObjectOperationRules(objectType, parameters, path, context) {
+    const objectParameter = objectReferenceParameter(parameters, objectType);
+    if (!objectParameter) {
+        addMissingObjectParameterDiagnostic("Delete", objectType, path, context);
+        return [];
+    }
+    return [deleteObjectRule(objectParameter)];
+}
+function addMissingObjectParameterDiagnostic(operationName, objectType, path, context) {
+    addSkippedActionOperationDiagnostic(`${operationName} operation for ${objectType.apiName.original} has no object reference parameter; operation was not emitted.`, path, context);
+}
+function createObjectRule(objectType, parameters) {
+    return {
+        addObjectRule: {
+            objectTypeId: objectType.apiName.sanitized,
+            propertyValues: propertyValuesFor(objectType, parameters),
+            structFieldValues: {},
+        },
+        type: "addObjectRule",
+    };
+}
+function modifyObjectRule(objectParameter, objectType, parameters) {
+    return {
+        modifyObjectRule: {
+            objectToModify: objectParameter.id.sanitized,
+            propertyValues: propertyValuesFor(objectType, parameters),
+            structFieldValues: {},
+        },
+        type: "modifyObjectRule",
+    };
+}
+function deleteObjectRule(objectParameter) {
+    return {
+        deleteObjectRule: {
+            objectToDelete: objectParameter.id.sanitized,
+        },
+        type: "deleteObjectRule",
+    };
+}
+function propertyValuesFor(objectType, parameters) {
+    const objectPropertiesByName = new Map(objectType.properties.flatMap((property) => [
+        [property.apiName.original, property.apiName.sanitized],
+        [property.apiName.sanitized, property.apiName.sanitized],
+        [property.originalId, property.apiName.sanitized],
+    ]));
+    return Object.fromEntries(parameters.flatMap((parameter) => {
+        const objectProperty = objectPropertiesByName.get(parameter.id.original) ??
+            objectPropertiesByName.get(parameter.id.sanitized);
+        return objectProperty
+            ? [
+                [
+                    objectProperty,
+                    { parameterId: parameter.id.sanitized, type: "parameterId" },
+                ],
+            ]
+            : [];
+    }));
+}
+function objectReferenceParameter(parameters, objectType) {
+    return parameters.find((parameter) => isObjectParameterType(parameter.type, "objectReference") &&
+        parameter.type.objectReference.objectTypeId ===
+            objectType.apiName.sanitized);
+}
+function isObjectParameterType(type, expectedType) {
+    return (typeof type === "object" &&
+        type !== null &&
+        stringField(type, "type") === expectedType);
+}
+function actionRuleObjectTypeApiName(rule, action) {
+    const ruleBody = ruleBodyFor(rule);
+    return (stringField(ruleBody, "objectTypeId") ??
+        stringField(ruleBody, "objectTypeApiName") ??
+        actionRuleTargetParameterObjectTypeApiName(ruleBody, action));
+}
+function actionRuleTargetParameterObjectTypeApiName(ruleBody, action) {
+    const targetParameterId = ["objectToModify", "objectToDelete"]
+        .map((field) => stringField(ruleBody, field))
+        .find((value) => typeof value === "string");
+    const targetParameter = actionFormParameters(action).find((parameter) => parameter.id === targetParameterId);
+    return targetParameter?.type
+        ? objectTypeReferenceApiName(targetParameter.type)
+        : undefined;
+}
+function actionOperationType(type) {
+    const typeMap = {
+        addObjectRule: "createObject",
+        addOrModifyObjectRuleV2: "modifyObject",
+        deleteObjectRule: "deleteObject",
+        modifyObjectRule: "modifyObject",
+    };
+    return type ? (typeMap[type] ?? type) : undefined;
+}
+function ruleBodyFor(rule) {
+    const type = rule.type;
+    if (!type) {
+        return rule;
+    }
+    const body = rule[type];
+    return typeof body === "object" && body !== null
+        ? body
+        : rule;
+}
+function ruleType(rule) {
+    return typeof rule === "object" && rule !== null
+        ? (stringField(rule, "type") ?? "unknown")
+        : "unknown";
 }
 function actionRules(action) {
     return action.actionTypeLogic?.logic?.rules ?? [];
 }
+function actionDisplayName(action, fallback) {
+    return displayNameFor(action.metadata?.displayMetadata, fallback);
+}
 function actionStatus(action, actionIndex, diagnostics) {
     return normalizeStatus(action.metadata?.status, `$.actionTypes[${actionIndex}].metadata.status`, diagnostics);
 }
+function inferParameterRequired(parameter) {
+    const defaultValidation = recordField(parameter.validation, "defaultValidation");
+    const validation = recordField(defaultValidation, "validation");
+    return (stringField(recordField(validation, "required"), "type") === "required");
+}
+function recordField(record, key) {
+    if (!isRecord(record)) {
+        return undefined;
+    }
+    const value = record[key];
+    return isRecord(value) ? value : undefined;
+}
+function stringField(record, key) {
+    return typeof record === "object" &&
+        record !== null &&
+        typeof record[key] === "string"
+        ? record[key]
+        : undefined;
+}

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

@@ -1 +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"}
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../src/foundry-import/convert.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEX,gBAAgB,EAMhB,MAAM,YAAY,CAAC;AAGpB,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAoFvE"}

package/dist/foundry-import/convert.js

@@ -1,5 +1,5 @@
 import { normalizeAction } from "./actions.js";
-import { normalizeInterface } from "./interfaces.js";
+import { addInterfaceReferences, normalizeInterface } from "./interfaces.js";
 import { createNameAllocator } from "./names.js";
 import { normalizeObject } from "./objects.js";
 import { parseFoundryV2Export } from "./parse.js";
@@ -13,19 +13,47 @@ export function convertFoundryV2Export(input) {
     const generalNameAllocator = createNameAllocator();
     const relationNameAllocator = createNameAllocator();
     const variableNameAllocator = createNameAllocator();
+    const sharedProperties = foundryExport.sharedProperties.map((sharedProperty, sharedPropertyIndex) => normalizeSharedProperty(sharedProperty, sharedPropertyIndex, generalNameAllocator, variableNameAllocator, diagnostics));
+    const sharedPropertiesByOriginalApiName = indexSharedPropertiesByApiName(sharedProperties);
+    const sharedPropertiesByRid = indexSharedPropertiesByRid(sharedProperties);
+    const interfacesWithoutReferences = foundryExport.interfaces.map((interfaceType, interfaceIndex) => normalizeInterface(interfaceType, interfaceIndex, {
+        diagnostics,
+        interfaceNameAllocator: generalNameAllocator,
+        sharedPropertiesByOriginalApiName,
+        sharedPropertiesByRid,
+        variableNameAllocator,
+    }));
+    const interfacesByApiName = indexInterfacesByApiName(interfacesWithoutReferences);
+    const interfaces = interfacesWithoutReferences.map((interfaceType, index) => {
+        const sourceInterface = foundryExport.interfaces[index];
+        return sourceInterface
+            ? addInterfaceReferences(sourceInterface, interfaceType, index, interfacesByApiName, diagnostics)
+            : interfaceType;
+    });
+    const interfacesWithReferencesByApiName = indexInterfacesByApiName(interfaces);
     const objects = foundryExport.objectTypes.map((objectType, objectIndex) => normalizeObject(objectType, objectIndex, {
         diagnostics,
+        interfacesByApiName: interfacesWithReferencesByApiName,
         objectNameAllocator,
         variableNameAllocator,
     }));
     const objectsByRid = indexObjectsByRid(objects);
+    const objectsByApiName = indexObjectsByApiName(objects);
     return {
-        actions: foundryExport.actionTypes.map((action, actionIndex) => normalizeAction(action, actionIndex, generalNameAllocator, diagnostics)),
+        actions: foundryExport.actionTypes.flatMap((action, actionIndex) => {
+            const normalized = normalizeAction(action, actionIndex, {
+                actionNameAllocator: generalNameAllocator,
+                diagnostics,
+                objectsByApiName,
+                variableNameAllocator,
+            });
+            return normalized ? [normalized] : [];
+        }),
         diagnostics,
-        interfaces: foundryExport.interfaces.map((interfaceType, interfaceIndex) => normalizeInterface(interfaceType, interfaceIndex, generalNameAllocator, variableNameAllocator, diagnostics)),
+        interfaces,
         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)),
+        sharedProperties,
         sourceVersion: foundryExport.version,
         typeGroups: foundryExport.typeGroups.map(normalizeTypeGroup),
     };
@@ -39,6 +67,42 @@ function indexObjectsByRid(objects) {
     }
     return objectsByRid;
 }
+function indexObjectsByApiName(objects) {
+    const objectsByApiName = new Map();
+    for (const object of objects) {
+        objectsByApiName.set(object.apiName.original, object);
+        objectsByApiName.set(object.apiName.sanitized, object);
+        if (object.id) {
+            objectsByApiName.set(object.id, object);
+        }
+    }
+    return objectsByApiName;
+}
+function indexInterfacesByApiName(interfaces) {
+    const interfacesByApiName = new Map();
+    for (const interfaceType of interfaces) {
+        interfacesByApiName.set(interfaceType.apiName.original, interfaceType);
+        interfacesByApiName.set(interfaceType.apiName.sanitized, interfaceType);
+    }
+    return interfacesByApiName;
+}
+function indexSharedPropertiesByApiName(sharedProperties) {
+    const sharedPropertiesByApiName = new Map();
+    for (const sharedProperty of sharedProperties) {
+        sharedPropertiesByApiName.set(sharedProperty.apiName.original, sharedProperty);
+        sharedPropertiesByApiName.set(sharedProperty.apiName.sanitized, sharedProperty);
+    }
+    return sharedPropertiesByApiName;
+}
+function indexSharedPropertiesByRid(sharedProperties) {
+    const sharedPropertiesByRid = new Map();
+    for (const sharedProperty of sharedProperties) {
+        if (sharedProperty.rid) {
+            sharedPropertiesByRid.set(sharedProperty.rid, sharedProperty);
+        }
+    }
+    return sharedPropertiesByRid;
+}
 function normalizeTypeGroup(typeGroup) {
     return {
         displayName: displayNameFor(typeGroup.displayMetadata, typeGroup.rid ?? "Type Group"),

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

@@ -1 +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"}
+{"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,CAsBxB"}