@elevasis/sdk 1.27.1 → 1.28.1

package/dist/test-utils/index.js

@@ -5857,8 +5857,8 @@ async function processMemory(memoryManager, response, logger, iteration) {
         continue;
       }
       const startTime = Date.now();
-      const stringValue = typeof content === "string" ? content : JSON.stringify(content);
-      memoryManager.set(key, stringValue);
+      const stringValue2 = typeof content === "string" ? content : JSON.stringify(content);
+      memoryManager.set(key, stringValue2);
       const endTime = Date.now();
       logger.action("memory-set", `Set: ${key}`, iteration, startTime, endTime, endTime - startTime);
     }
@@ -6966,6 +6966,19 @@ DisplayMetadataSchema.extend({
 function childSystemsOf(system) {
   return system.systems ?? system.subsystems ?? {};
 }
+function getSystem(model, path) {
+  const flatMatch = model.systems[path];
+  if (flatMatch !== void 0) return flatMatch;
+  const segments = path.split(".");
+  let current = model.systems;
+  let node;
+  for (const seg of segments) {
+    node = current[seg];
+    if (node === void 0) return void 0;
+    current = childSystemsOf(node);
+  }
+  return node;
+}
 function listAllSystems(model) {
   const results = [];
   function walk(map2, prefix) {
@@ -8536,6 +8549,70 @@ function compileOrganizationOntology(model) {
   addLegacyActionProjections(ontology, diagnostics, sourcesById, model.actions ?? {}, model.entities ?? {});
   return { ontology: sortResolvedOntologyIndex(ontology), diagnostics };
 }
+
+// ../core/src/organization-model/migration-helpers.ts
+function catalogRecords(model) {
+  return Object.values(compileOrganizationOntology(model).ontology.catalogTypes);
+}
+function systemScope(id, fallback) {
+  return parseOntologyId(id).scope || fallback || "";
+}
+function entriesOf(catalog) {
+  return Object.entries(catalog.entries ?? {}).map(([id, value]) => [
+    id,
+    value && typeof value === "object" && !Array.isArray(value) ? value : {}
+  ]);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function numberValue(value, fallback = 0) {
+  return typeof value === "number" ? value : fallback;
+}
+function appliesToLocalId(catalog) {
+  const appliesTo = catalog.appliesTo;
+  if (appliesTo === void 0) return void 0;
+  return parseOntologyId(appliesTo).localId;
+}
+function appliesToEntityKind(catalog) {
+  const id = appliesToLocalId(catalog);
+  if (id === "company" || id === "contact" || id === "project" || id === "milestone" || id === "task") return id;
+  if (id === "deal") return void 0;
+  return void 0;
+}
+function getLeadGenStageCatalog(model) {
+  const results = {};
+  for (const catalog of catalogRecords(model).filter(
+    (record) => record.kind === "stage" && (record.ownerSystemId ?? systemScope(record.id)) === "sales.lead-gen"
+  )) {
+    const catalogEntity = appliesToEntityKind(catalog);
+    if (catalogEntity !== "company" && catalogEntity !== "contact") continue;
+    for (const [entryId, entry] of entriesOf(catalog)) {
+      const entity = entry.entity === "contact" ? "contact" : entry.entity === "company" ? "company" : catalogEntity;
+      const additionalEntities = stringArray(entry.additionalEntities).filter(
+        (item) => item === "company" || item === "contact"
+      );
+      const recordEntity = entry.recordEntity === "company" || entry.recordEntity === "contact" ? entry.recordEntity : void 0;
+      const recordStageKey = stringValue(entry.recordStageKey);
+      results[entryId] = {
+        key: entryId,
+        label: stringValue(entry.label) ?? entryId,
+        description: stringValue(entry.description) ?? "",
+        order: numberValue(entry.order),
+        entity,
+        ...additionalEntities.length > 0 ? { additionalEntities } : {},
+        ...recordEntity ? { recordEntity } : {},
+        ...recordStageKey ? { recordStageKey } : {}
+      };
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(results).sort(([, a3], [, b2]) => a3.order - b2.order || a3.key.localeCompare(b2.key))
+  );
+}
 z.object({
   success: z.boolean(),
   tool: z.string(),
@@ -8548,6 +8625,455 @@ z.object({
   credential: z.string().describe("Credential name registered for this integration")
 });
 
+// ../core/src/business/acquisition/ontology-validation.ts
+var LEAD_GEN_API_INTERFACE = {
+  interfaceKey: "api",
+  readinessProfile: "sales.lead-gen.api"
+};
+var CRM_API_INTERFACE = {
+  systemPath: "sales.crm",
+  interfaceKey: "api",
+  readinessProfile: "sales.crm.api"
+};
+var LEAD_GEN_CRM_HANDOFF_INTERFACE = {
+  systemPath: "sales.lead-gen",
+  interfaceKey: "crm-handoff",
+  readinessProfile: "sales.lead-gen.crm-handoff"
+};
+CRM_API_INTERFACE.readinessProfile;
+var LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "object",
+  localId: "list"
+});
+var LEAD_GEN_COMPANY_OBJECT_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "object",
+  localId: "company"
+});
+var LEAD_GEN_CONTACT_OBJECT_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "object",
+  localId: "contact"
+});
+var LEAD_GEN_BUILD_TEMPLATE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "build-template"
+});
+var LEAD_GEN_COMPANY_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "company-stage"
+});
+var LEAD_GEN_CONTACT_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "contact-stage"
+});
+var CRM_PIPELINE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.crm",
+  kind: "catalog",
+  localId: "crm.pipeline"
+});
+var LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID = formatOntologyId({
+  scope: "sales.lead-gen",
+  kind: "catalog",
+  localId: "lead-gen.stage-catalog"
+});
+function createLeadGenStageCatalog(model) {
+  return {
+    id: LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID,
+    label: "Lead Gen Processing Stages",
+    ownerSystemId: "sales.lead-gen",
+    kind: "processing-stage-catalog",
+    entries: Object.fromEntries(
+      Object.entries(getLeadGenStageCatalog(model)).map(([key, entry]) => [
+        key,
+        {
+          ...entry
+        }
+      ])
+    ),
+    legacyCatalogKey: "LEAD_GEN_STAGE_CATALOG"
+  };
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function addReadinessIssue(issues, family, code, message, details = {}) {
+  issues.push({
+    family,
+    code,
+    message,
+    ...details
+  });
+}
+function formatInterfaceIdentity(systemPath, interfaceKey) {
+  return `${systemPath}/${interfaceKey}`;
+}
+function profileForInterface(systemPath, interfaceKey, readinessProfile) {
+  return readinessProfile ?? `${systemPath}.${interfaceKey}`;
+}
+function readinessMarkerPath(context) {
+  return context.interfaceKey === "api" ? `systems.${context.systemPath}.apiInterface` : `systems.${context.systemPath}.derivedCrmHandoffReadiness`;
+}
+function getActiveScopedResources(model, resourceIds, issues, context) {
+  const resources = [];
+  for (const [index2, resourceId] of resourceIds.entries()) {
+    const resource = model.resources?.[resourceId];
+    const path = `${readinessMarkerPath(context)}.resourceIds.${index2}`;
+    if (resource === void 0) {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_INTERFACE_NOT_READY",
+        "missing-resource",
+        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes missing resource "${resourceId}".`,
+        { path, ref: resourceId }
+      );
+      continue;
+    }
+    if (resource.systemPath !== context.systemPath) {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_INTERFACE_INVALID",
+        "resource-system-mismatch",
+        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes resource "${resourceId}" from system "${resource.systemPath}".`,
+        { path, ref: resourceId }
+      );
+      continue;
+    }
+    if (resource.status !== "active") {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_INTERFACE_NOT_READY",
+        "inactive-resource",
+        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes inactive resource "${resourceId}".`,
+        { path, ref: resourceId }
+      );
+      continue;
+    }
+    resources.push(resource);
+  }
+  return resources;
+}
+function resourceBindingIds(resources, key) {
+  return new Set(resources.flatMap((resource) => resource.ontology?.[key] ?? []));
+}
+function requireScopedBinding(issues, boundIds, bindingKey, ontologyId, context) {
+  if (boundIds.has(ontologyId)) return;
+  addReadinessIssue(
+    issues,
+    "SYSTEM_INTERFACE_NOT_READY",
+    "missing-resource-binding",
+    `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" has no active scoped resource with ontology.${bindingKey} binding "${ontologyId}".`,
+    { path: `${readinessMarkerPath(context)}.resourceIds`, ref: ontologyId }
+  );
+}
+function ontologyOwnerMatches(ontologyId, expectedSystemPath, catalog) {
+  if (catalog?.ownerSystemId !== void 0) return catalog.ownerSystemId === expectedSystemPath;
+  return parseOntologyId(ontologyId).scope === expectedSystemPath;
+}
+function requireObjectReadiness(issues, index2, objectId, context) {
+  const object2 = index2.ontology.objectTypes[objectId];
+  if (object2 === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "missing-object",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing required object type "${objectId}".`,
+      { ref: objectId }
+    );
+    return;
+  }
+  const ownerSystemId = object2.ownerSystemId ?? parseOntologyId(objectId).scope;
+  if (ownerSystemId !== context.systemPath) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "foreign-object",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires object "${objectId}" owned by "${ownerSystemId}".`,
+      { ref: objectId }
+    );
+  }
+}
+function requireCatalogReadiness(issues, index2, catalogId, context) {
+  const catalog = index2.ontology.catalogTypes[catalogId];
+  if (catalog === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "missing-catalog",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing required catalog "${catalogId}".`,
+      { ref: catalogId }
+    );
+    return void 0;
+  }
+  if (context.allowForeignOwner !== true && !ontologyOwnerMatches(catalogId, context.systemPath, catalog)) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "foreign-catalog",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires catalog "${catalogId}" owned by "${catalog.ownerSystemId ?? parseOntologyId(catalogId).scope}".`,
+      { ref: catalogId }
+    );
+  }
+  if (Object.keys(getCatalogEntries(catalog)).length === 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "empty-catalog",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires catalog entries for "${catalogId}".`,
+      { ref: catalogId }
+    );
+  }
+  return catalog;
+}
+function requireLeadGenInterfaceReadiness(issues, index2, resources, context) {
+  const reads = resourceBindingIds(resources, "reads");
+  const catalogs = resourceBindingIds(resources, "usesCatalogs");
+  for (const objectId of [
+    LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID,
+    LEAD_GEN_COMPANY_OBJECT_ONTOLOGY_ID,
+    LEAD_GEN_CONTACT_OBJECT_ONTOLOGY_ID
+  ]) {
+    requireObjectReadiness(issues, index2, objectId, context);
+    requireScopedBinding(issues, reads, "reads", objectId, context);
+  }
+  for (const catalogId of [
+    LEAD_GEN_BUILD_TEMPLATE_CATALOG_ONTOLOGY_ID,
+    LEAD_GEN_COMPANY_STAGE_CATALOG_ONTOLOGY_ID,
+    LEAD_GEN_CONTACT_STAGE_CATALOG_ONTOLOGY_ID
+  ]) {
+    requireCatalogReadiness(issues, index2, catalogId, context);
+    requireScopedBinding(issues, catalogs, "usesCatalogs", catalogId, context);
+  }
+  const templateStepCatalog = findLeadGenTemplateStepCatalog(index2);
+  if (templateStepCatalog === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "missing-template-step-catalog",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" is missing a lead-gen template-step catalog.`
+    );
+  } else {
+    requireCatalogReadiness(issues, index2, templateStepCatalog.id, context);
+    requireScopedBinding(issues, catalogs, "usesCatalogs", templateStepCatalog.id, context);
+  }
+  const leadGenStageCatalog = requireCatalogReadiness(issues, index2, LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID, context);
+  return leadGenStageCatalog;
+}
+function requireCrmInterfaceReadiness(issues, index2, resources, context) {
+  const catalogs = resourceBindingIds(resources, "usesCatalogs");
+  const crmPipelineCatalog = requireCatalogReadiness(issues, index2, CRM_PIPELINE_CATALOG_ONTOLOGY_ID, context);
+  requireScopedBinding(issues, catalogs, "usesCatalogs", CRM_PIPELINE_CATALOG_ONTOLOGY_ID, context);
+  return crmPipelineCatalog;
+}
+function findSystemInterfaceGrant(model, consumer, provider) {
+  return Object.values(model.topology?.relationships ?? {}).find((relationship) => {
+    const grant = relationship.metadata?.["systemInterfaceGrant"];
+    if (!isPlainRecord(grant) || !isPlainRecord(grant.consumer) || !isPlainRecord(grant.provider)) return false;
+    return grant.consumer.systemPath === consumer.systemPath && grant.consumer.interfaceKey === consumer.interfaceKey && grant.provider.systemPath === provider.systemPath && grant.provider.interfaceKey === provider.interfaceKey;
+  });
+}
+function requireHandoffBridgeReadiness(issues, model, context) {
+  const crmResult = computeInterfaceReadiness(model, CRM_API_INTERFACE);
+  if (!crmResult.ready) {
+    for (const issue of crmResult.issues) {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_BRIDGE_NOT_READY",
+        issue.code,
+        `Provider interface ${formatInterfaceIdentity(CRM_API_INTERFACE.systemPath, CRM_API_INTERFACE.interfaceKey)} is not ready: ${issue.message}`,
+        { path: issue.path, ref: issue.ref }
+      );
+    }
+  }
+  const bridgeGrant = findSystemInterfaceGrant(model, context, CRM_API_INTERFACE);
+  if (bridgeGrant === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_BRIDGE_NOT_READY",
+      "missing-topology-grant",
+      `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" requires a scoped topology grant to "${formatInterfaceIdentity(CRM_API_INTERFACE.systemPath, CRM_API_INTERFACE.interfaceKey)}".`
+    );
+  }
+  return bridgeGrant;
+}
+function getLeadGenCrmHandoffResourceIds(model) {
+  return Object.values(model.resources ?? {}).filter(
+    (resource) => resource.systemPath === LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath && resource.ontology?.usesCatalogs?.includes(CRM_PIPELINE_CATALOG_ONTOLOGY_ID) === true
+  ).map((resource) => resource.id);
+}
+function getSystemInterfaceReadinessMarker(model, request) {
+  const system = getSystem(model, request.systemPath);
+  if (system === void 0) return void 0;
+  if (request.interfaceKey === LEAD_GEN_API_INTERFACE.interfaceKey) {
+    return system.apiInterface;
+  }
+  if (request.systemPath === LEAD_GEN_CRM_HANDOFF_INTERFACE.systemPath && request.interfaceKey === LEAD_GEN_CRM_HANDOFF_INTERFACE.interfaceKey) {
+    return {
+      lifecycle: "active",
+      readinessProfile: LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile,
+      resourceIds: getLeadGenCrmHandoffResourceIds(model)
+    };
+  }
+  return void 0;
+}
+function mergeLeadGenDerivedCatalogs(model) {
+  const baseCatalogTypes = model.ontology?.catalogTypes ?? {};
+  const derivedCatalogTypes = {};
+  if (baseCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] === void 0) {
+    derivedCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] = createLeadGenStageCatalog(model);
+  }
+  if (Object.keys(derivedCatalogTypes).length === 0) return model;
+  return {
+    ...model,
+    ontology: {
+      ...model.ontology ?? {},
+      catalogTypes: {
+        ...baseCatalogTypes,
+        ...derivedCatalogTypes
+      }
+    }
+  };
+}
+function compileBusinessOntology(model, contractId) {
+  const compilation = compileOrganizationOntology(mergeLeadGenDerivedCatalogs(model));
+  if (compilation.diagnostics.length > 0) {
+    const summary = compilation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
+    throw new Error(`${contractId} ontology validation index failed to compile: ${summary}`);
+  }
+  return {
+    ontology: compilation.ontology,
+    actionTypesByLegacyId: indexActionTypesByLegacyId(compilation.ontology.actionTypes)
+  };
+}
+function tryCompileBusinessOntology(model, readinessProfile, issues) {
+  try {
+    return compileBusinessOntology(model, readinessProfile);
+  } catch (error) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "ontology-compile-failed",
+      error instanceof Error ? error.message : String(error)
+    );
+    return void 0;
+  }
+}
+function computeInterfaceReadiness(model, request) {
+  const issues = [];
+  const system = getSystem(model, request.systemPath);
+  const systemInterface = getSystemInterfaceReadinessMarker(model, request);
+  const readinessProfile = systemInterface === void 0 ? void 0 : profileForInterface(request.systemPath, request.interfaceKey, systemInterface.readinessProfile);
+  const scopedResourceIds = systemInterface?.resourceIds ?? [];
+  if (system === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_MISSING",
+      "missing-system",
+      `System "${request.systemPath}" is missing.`,
+      { ref: request.systemPath }
+    );
+    return { ready: false, systemPath: request.systemPath, interfaceKey: request.interfaceKey, scopedResourceIds, issues };
+  }
+  if (systemInterface === void 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_MISSING",
+      "missing-interface",
+      `System "${request.systemPath}" does not declare interface "${request.interfaceKey}".`,
+      { path: readinessMarkerPath(request) }
+    );
+    return { ready: false, systemPath: request.systemPath, interfaceKey: request.interfaceKey, scopedResourceIds, issues };
+  }
+  if (systemInterface.lifecycle !== "active") {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_DISABLED",
+      "inactive-interface",
+      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" lifecycle is "${systemInterface.lifecycle}".`,
+      { path: `${readinessMarkerPath(request)}.lifecycle` }
+    );
+  }
+  const supportedProfiles = [
+    LEAD_GEN_API_INTERFACE.readinessProfile,
+    CRM_API_INTERFACE.readinessProfile,
+    LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile
+  ];
+  const supportedProfile = readinessProfile !== void 0 && supportedProfiles.some((profile) => profile === readinessProfile);
+  if (!supportedProfile) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "unknown-readiness-profile",
+      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" references unknown readiness profile "${readinessProfile}".`,
+      { path: `${readinessMarkerPath(request)}.readinessProfile`, ref: readinessProfile }
+    );
+    return {
+      ready: false,
+      systemPath: request.systemPath,
+      interfaceKey: request.interfaceKey,
+      readinessProfile,
+      scopedResourceIds,
+      issues
+    };
+  }
+  if (scopedResourceIds.length === 0) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_NOT_READY",
+      "missing-scoped-resources",
+      `System Interface "${formatInterfaceIdentity(request.systemPath, request.interfaceKey)}" must scope at least one active resource.`,
+      { path: `${readinessMarkerPath(request)}.resourceIds` }
+    );
+  }
+  const checkedReadinessProfile = readinessProfile;
+  if (checkedReadinessProfile === void 0) {
+    throw new Error("Supported readiness profile unexpectedly resolved to undefined");
+  }
+  const resources = getActiveScopedResources(model, scopedResourceIds, issues, request);
+  const index2 = tryCompileBusinessOntology(model, checkedReadinessProfile, issues);
+  if (index2 !== void 0) {
+    if (checkedReadinessProfile === LEAD_GEN_API_INTERFACE.readinessProfile) {
+      requireLeadGenInterfaceReadiness(issues, index2, resources, request);
+    } else if (checkedReadinessProfile === CRM_API_INTERFACE.readinessProfile) {
+      requireCrmInterfaceReadiness(issues, index2, resources, request);
+    } else if (checkedReadinessProfile === LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile) {
+      requireLeadGenInterfaceReadiness(issues, index2, resources, request);
+      requireCrmInterfaceReadiness(issues, index2, resources, { ...request, allowForeignOwner: true });
+      requireHandoffBridgeReadiness(issues, model, request);
+    }
+  }
+  return {
+    ready: issues.length === 0,
+    systemPath: request.systemPath,
+    interfaceKey: request.interfaceKey,
+    readinessProfile,
+    scopedResourceIds,
+    issues
+  };
+}
+function findLeadGenTemplateStepCatalog(index2) {
+  return Object.values(index2.ontology.catalogTypes).find(
+    (catalog) => catalog.ownerSystemId === "sales.lead-gen" && catalog.kind === "template-step" && catalog.appliesTo === LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID
+  );
+}
+function indexActionTypesByLegacyId(actionTypes) {
+  const byLegacyId = {};
+  for (const actionType of Object.values(actionTypes)) {
+    const legacyActionId = actionType["legacyActionId"];
+    if (typeof legacyActionId === "string") {
+      byLegacyId[legacyActionId] = actionType;
+    }
+  }
+  return byLegacyId;
+}
+function getCatalogEntries(catalog) {
+  return isPlainRecord(catalog.entries) ? catalog.entries : {};
+}
+
 // ../core/src/platform/registry/validation.ts
 var RegistryValidationError = class extends Error {
   constructor(orgName, resourceId, field, message) {
@@ -8638,7 +9164,7 @@ function ontologyIndexForKind(index2, kind) {
 function sameJson(left, right) {
   return JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
 }
-function addOntologyBindingIssues(issues, orgName, resource, ontologyIndex) {
+function addOntologyBindingIssues(issues, orgName, resource, ontologyIndex, organizationModel) {
   const binding = resource.ontology;
   if (binding === void 0) return;
   const hasOperationalOntologyBinding = binding.primaryAction !== void 0 || (binding.reads?.length ?? 0) > 0 || (binding.writes?.length ?? 0) > 0 || (binding.usesCatalogs?.length ?? 0) > 0 || (binding.emits?.length ?? 0) > 0;
@@ -8681,6 +9207,45 @@ function addOntologyBindingIssues(issues, orgName, resource, ontologyIndex) {
   validateRefs("writes", "object", binding.writes);
   validateRefs("usesCatalogs", "catalog", binding.usesCatalogs);
   validateRefs("emits", "event", binding.emits);
+  addOntologyTopologyGrantIssues(issues, orgName, resource, organizationModel);
+}
+function addOntologyTopologyGrantIssues(issues, orgName, resource, organizationModel) {
+  const binding = resource.ontology;
+  if (binding === void 0) return;
+  const refs = [
+    ...binding.actions ?? [],
+    ...binding.primaryAction !== void 0 ? [binding.primaryAction] : [],
+    ...binding.reads ?? [],
+    ...binding.writes ?? [],
+    ...binding.usesCatalogs ?? [],
+    ...binding.emits ?? []
+  ];
+  for (const ontologyId of new Set(refs)) {
+    const parsed = parseOntologyId(ontologyId);
+    if (parsed.isGlobal || parsed.scope === resource.systemPath) continue;
+    if (hasScopedTopologyGrant(organizationModel, resource, parsed.scope, ontologyId)) continue;
+    const missingGrant = `systemInterfaceGrant(${resource.systemPath} -> ${parsed.scope}, resourceIds: ["${resource.id}"], ontologyIds: ["${ontologyId}"])`;
+    addGovernanceIssue(
+      issues,
+      "ontology-topology-grant-missing",
+      orgName,
+      resource.id,
+      `[${orgName}] Resource '${resource.id}' in system '${resource.systemPath}' references ontology '${ontologyId}' from system '${parsed.scope}' without scoped topology grant '${missingGrant}'.`
+    );
+  }
+}
+function hasScopedTopologyGrant(organizationModel, resource, targetSystemPath, ontologyId) {
+  return Object.values(organizationModel.topology?.relationships ?? {}).some((relationship) => {
+    if (relationship.kind !== "uses") return false;
+    const grant = relationship.metadata?.["systemInterfaceGrant"];
+    if (!isSystemInterfaceGrantRecord(grant)) return false;
+    return grant.consumer.systemPath === resource.systemPath && grant.provider.systemPath === targetSystemPath && grant.resourceIds.includes(resource.id) && grant.ontologyIds.includes(ontologyId);
+  });
+}
+function isSystemInterfaceGrantRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const grant = value;
+  return typeof grant.consumer?.systemPath === "string" && typeof grant.consumer.interfaceKey === "string" && typeof grant.provider?.systemPath === "string" && typeof grant.provider.interfaceKey === "string" && Array.isArray(grant.resourceIds) && grant.resourceIds.every((id) => typeof id === "string") && Array.isArray(grant.ontologyIds) && grant.ontologyIds.every((id) => typeof id === "string");
 }
 function addTopologyIssues(issues, orgName, deployment, organizationModel, systemsById, omResourcesById, ontologyIndex) {
   const relationships = organizationModel.topology?.relationships;
@@ -8795,7 +9360,7 @@ function validateResourceGovernance(orgName, deployment, organizationModel = dep
         `[${orgName}] Resource '${resource.id}' ontology descriptor mismatch between code and OM.`
       );
     }
-    addOntologyBindingIssues(issues, orgName, resource, ontologyIndex);
+    addOntologyBindingIssues(issues, orgName, resource, ontologyIndex, organizationModel);
   }
   for (const runtimeResource of runtimeResources) {
     const omResource = omResourcesById.get(runtimeResource.resourceId);
@@ -8845,6 +9410,41 @@ function validateResourceGovernance(orgName, deployment, organizationModel = dep
     issues
   };
 }
+function addSystemInterfaceIssue(issues, orgName, systemPath, interfaceKey, issue) {
+  issues.push({
+    type: issue.family,
+    orgName,
+    systemPath,
+    interfaceKey,
+    code: issue.code,
+    path: issue.path,
+    ref: issue.ref,
+    message: `[${orgName}] ${issue.family}:${issue.code}: ${issue.message}`
+  });
+}
+function validateDeclaredSystemInterfaceReadiness(orgName, organizationModel) {
+  const issues = [];
+  if (organizationModel === void 0) return { valid: true, issues };
+  const model = organizationModel;
+  for (const { path, system } of listAllSystems(model)) {
+    if (system.apiInterface === void 0) continue;
+    const interfaceKey = "api";
+    const result = computeInterfaceReadiness(model, { systemPath: path, interfaceKey });
+    for (const issue of result.issues) {
+      addSystemInterfaceIssue(issues, orgName, path, interfaceKey, issue);
+    }
+  }
+  if (issues.length > 0) {
+    const first = issues[0];
+    throw new RegistryValidationError(
+      first.orgName,
+      `${first.systemPath}/${first.interfaceKey}`,
+      first.path ?? "organizationModel.systems.apiInterface",
+      first.message
+    );
+  }
+  return { valid: true, issues };
+}
 function validateDeploymentSpec(orgName, resources) {
   const seenIds = /* @__PURE__ */ new Set();
   resources.workflows?.forEach((workflow) => {
@@ -8882,6 +9482,7 @@ function validateDeploymentSpec(orgName, resources) {
     }
   });
   validateResourceGovernance(orgName, resources);
+  validateDeclaredSystemInterfaceReadiness(orgName, resources.organizationModel);
 }
 function validateResourceModelConfig(orgName, resourceId, modelConfig) {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/sdk",
-  "version": "1.27.1",
+  "version": "1.28.1",
   "description": "SDK for building Elevasis organization resources",
   "type": "module",
   "bin": {
@@ -58,7 +58,7 @@
     "tsup": "^8.0.0",
     "typescript": "5.9.2",
     "zod": "^4.1.0",
-    "@repo/core": "0.34.2",
+    "@repo/core": "0.35.1",
     "@repo/typescript-config": "0.0.0",
     "@repo/eslint-config": "0.0.0"
   },