@elevasis/sdk 1.27.1 → 1.28.0

package/dist/cli.cjs

@@ -37592,6 +37592,26 @@ var SystemUiSchema = external_exports.object({
   icon: IconNameSchema.optional(),
   order: external_exports.number().int().optional()
 });
+var SystemInterfaceKeySchema = ModelIdSchema;
+var SystemInterfaceLifecycleSchema = external_exports.enum(["draft", "active", "disabled", "deprecated", "archived"]).meta({ label: "System interface lifecycle", color: "teal" });
+var SystemInterfaceReadinessProfileSchema = external_exports.string().trim().min(1).max(200).regex(
+  /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*(?:\.[a-z0-9][a-z0-9-]*)?$/,
+  'Readiness profiles must use dotted lowercase identifiers (e.g. "sales.lead-gen.api")'
+);
+var SystemInterfaceResourceScopeSchema = external_exports.array(ModelIdSchema).default([]);
+var SystemApiInterfaceSchema = external_exports.object({
+  lifecycle: SystemInterfaceLifecycleSchema.default("active"),
+  readinessProfile: SystemInterfaceReadinessProfileSchema.optional(),
+  /**
+   * Resource ids that participate in this API interface. This scopes readiness
+   * derivation without duplicating authored required/provided contract refs.
+   */
+  resourceIds: SystemInterfaceResourceScopeSchema.optional()
+}).strict();
+var SystemInterfaceRefSchema = external_exports.object({
+  systemPath: SystemPathSchema,
+  interfaceKey: SystemInterfaceKeySchema
+}).strict();
 var JsonValueSchema = external_exports.lazy(
   () => external_exports.union([
     external_exports.string(),
@@ -37630,6 +37650,8 @@ var SystemEntrySchema = external_exports.object({
   policies: external_exports.array(ModelIdSchema.meta({ ref: "policy" })).default([]).optional(),
   /** Optional goals this system contributes to. */
   drivesGoals: external_exports.array(ModelIdSchema.meta({ ref: "goal" })).default([]).optional(),
+  /** Thin API runtime-boundary marker. Readiness is derived from scoped resources and topology. */
+  apiInterface: SystemApiInterfaceSchema.optional(),
   /** @deprecated Use lifecycle. Accepted for one publish cycle. */
   status: SystemStatusSchema.optional(),
   /** @deprecated Use ui.path. Kept for one-cycle Feature compatibility. */
@@ -38066,6 +38088,15 @@ var OmTopologyMetadataSchema = external_exports.record(external_exports.string()
   }
   visit(metadata, []);
 });
+var OmTopologySystemInterfaceGrantSchema = external_exports.object({
+  consumer: SystemInterfaceRefSchema,
+  provider: SystemInterfaceRefSchema,
+  resourceIds: external_exports.array(ResourceIdSchema).default([]),
+  ontologyIds: external_exports.array(OntologyIdSchema).default([])
+}).strict();
+var OmTopologySystemInterfaceGrantMetadataSchema = external_exports.object({
+  systemInterfaceGrant: OmTopologySystemInterfaceGrantSchema
+}).strict();
 var OmTopologyRelationshipSchema = external_exports.object({
   from: OmTopologyNodeRefSchema,
   kind: OmTopologyRelationshipKindSchema,
@@ -38617,6 +38648,26 @@ function refineOrganizationModel(model, ctx) {
       );
     }
   });
+  allSystems.forEach(({ path: systemPath, schemaPath, system }) => {
+    system.apiInterface?.resourceIds?.forEach((resourceId, resourceIndex) => {
+      const resource = resourcesById.get(resourceId);
+      if (resource === void 0) {
+        addIssue(
+          ctx,
+          [...schemaPath, "apiInterface", "resourceIds", resourceIndex],
+          `System Interface "${systemPath}/api" scopes unknown resource "${resourceId}"`
+        );
+        return;
+      }
+      if (resource.systemPath !== systemPath) {
+        addIssue(
+          ctx,
+          [...schemaPath, "apiInterface", "resourceIds", resourceIndex],
+          `System Interface "${systemPath}/api" scopes resource "${resourceId}" from system "${resource.systemPath}"`
+        );
+      }
+    });
+  });
   function validateResourceOntologyBinding(resourceId, bindingKey, expectedKind, ids) {
     const ontologyIds2 = ids === void 0 ? [] : Array.isArray(ids) ? ids : [ids];
     ontologyIds2.forEach((ontologyId, ontologyIndex) => {
@@ -40215,6 +40266,458 @@ function validateModelConfig(config3) {
   }
 }
 
+// ../core/src/business/acquisition/ontology-validation.ts
+var LEAD_GEN_API_INTERFACE = {
+  systemPath: "sales.lead-gen",
+  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"
+};
+var LEAD_GEN_API_READINESS_LABEL = LEAD_GEN_API_INTERFACE.readinessProfile;
+var CRM_API_READINESS_LABEL = CRM_API_INTERFACE.readinessProfile;
+var LEAD_GEN_CRM_HANDOFF_READINESS_LABEL = LEAD_GEN_CRM_HANDOFF_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 [index, resourceId] of resourceIds.entries()) {
+    const resource = model.resources?.[resourceId];
+    const path3 = `${readinessMarkerPath(context)}.resourceIds.${index}`;
+    if (resource === void 0) {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_INTERFACE_NOT_READY",
+        "missing-resource",
+        `System Interface "${formatInterfaceIdentity(context.systemPath, context.interfaceKey)}" scopes missing resource "${resourceId}".`,
+        { path: path3, 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: path3, 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: path3, 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, index, objectId, context) {
+  const object2 = index.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, index, catalogId, context) {
+  const catalog = index.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, index, 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, index, 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, index, catalogId, context);
+    requireScopedBinding(issues, catalogs, "usesCatalogs", catalogId, context);
+  }
+  const templateStepCatalog = findLeadGenTemplateStepCatalog(index);
+  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, index, templateStepCatalog.id, context);
+    requireScopedBinding(issues, catalogs, "usesCatalogs", templateStepCatalog.id, context);
+  }
+  const leadGenStageCatalog = requireCatalogReadiness(issues, index, LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID, context);
+  return leadGenStageCatalog;
+}
+function requireCrmInterfaceReadiness(issues, index, resources, context) {
+  const catalogs = resourceBindingIds(resources, "usesCatalogs");
+  const crmPipelineCatalog = requireCatalogReadiness(issues, index, 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 issue2 of crmResult.issues) {
+      addReadinessIssue(
+        issues,
+        "SYSTEM_BRIDGE_NOT_READY",
+        issue2.code,
+        `Provider interface ${formatInterfaceIdentity(CRM_API_INTERFACE.systemPath, CRM_API_INTERFACE.interfaceKey)} is not ready: ${issue2.message}`,
+        { path: issue2.path, ref: issue2.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 (error46) {
+    addReadinessIssue(
+      issues,
+      "SYSTEM_INTERFACE_INVALID",
+      "ontology-compile-failed",
+      error46 instanceof Error ? error46.message : String(error46)
+    );
+    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 index = tryCompileBusinessOntology(model, checkedReadinessProfile, issues);
+  if (index !== void 0) {
+    if (checkedReadinessProfile === LEAD_GEN_API_INTERFACE.readinessProfile) {
+      requireLeadGenInterfaceReadiness(issues, index, resources, request);
+    } else if (checkedReadinessProfile === CRM_API_INTERFACE.readinessProfile) {
+      requireCrmInterfaceReadiness(issues, index, resources, request);
+    } else if (checkedReadinessProfile === LEAD_GEN_CRM_HANDOFF_INTERFACE.readinessProfile) {
+      requireLeadGenInterfaceReadiness(issues, index, resources, request);
+      requireCrmInterfaceReadiness(issues, index, resources, { ...request, allowForeignOwner: true });
+      requireHandoffBridgeReadiness(issues, model, request);
+    }
+  }
+  return {
+    ready: issues.length === 0,
+    systemPath: request.systemPath,
+    interfaceKey: request.interfaceKey,
+    readinessProfile,
+    scopedResourceIds,
+    issues
+  };
+}
+function findLeadGenTemplateStepCatalog(index) {
+  return Object.values(index.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, field2, message) {
@@ -40305,7 +40808,7 @@ function ontologyIndexForKind(index, 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;
@@ -40348,6 +40851,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;
@@ -40463,7 +41005,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);
@@ -40513,6 +41055,41 @@ function validateResourceGovernance(orgName, deployment, organizationModel = dep
     issues
   };
 }
+function addSystemInterfaceIssue(issues, orgName, systemPath, interfaceKey, issue2) {
+  issues.push({
+    type: issue2.family,
+    orgName,
+    systemPath,
+    interfaceKey,
+    code: issue2.code,
+    path: issue2.path,
+    ref: issue2.ref,
+    message: `[${orgName}] ${issue2.family}:${issue2.code}: ${issue2.message}`
+  });
+}
+function validateDeclaredSystemInterfaceReadiness(orgName, organizationModel) {
+  const issues = [];
+  if (organizationModel === void 0) return { valid: true, issues };
+  const model = organizationModel;
+  for (const { path: path3, system } of listAllSystems(model)) {
+    if (system.apiInterface === void 0) continue;
+    const interfaceKey = "api";
+    const result = computeInterfaceReadiness(model, { systemPath: path3, interfaceKey });
+    for (const issue2 of result.issues) {
+      addSystemInterfaceIssue(issues, orgName, path3, interfaceKey, issue2);
+    }
+  }
+  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) => {
@@ -40550,6 +41127,7 @@ function validateDeploymentSpec(orgName, resources) {
     }
   });
   validateResourceGovernance(orgName, resources);
+  validateDeclaredSystemInterfaceReadiness(orgName, resources.organizationModel);
 }
 function validateResourceModelConfig(orgName, resourceId, modelConfig) {
   try {
@@ -44130,7 +44708,7 @@ function wrapAction(commandName, fn) {
 // package.json
 var package_default = {
   name: "@elevasis/sdk",
-  version: "1.27.1",
+  version: "1.28.0",
   description: "SDK for building Elevasis organization resources",
   type: "module",
   bin: {
@@ -44382,6 +44960,7 @@ function validateResourceGovernancePreflight(orgName, org, contractRegistry) {
   if (org.organizationModel !== void 0) {
     OrganizationModelSchema.parse(org.organizationModel);
   }
+  validateDeclaredSystemInterfaceReadiness(orgName, org.organizationModel);
   if (process.env.ELEVASIS_RESOURCE_VALIDATOR === "warn-only") return;
   validateResourceGovernance(orgName, org, org.organizationModel, { mode: "strict" });
   const contractRefs = listOrganizationModelContractRefs(org);