@elevasis/sdk 1.27.1 → 1.28.1

package/dist/index.js

@@ -344,6 +344,19 @@ function compileOrganizationOntology(model) {
 function childSystemsOf2(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 = childSystemsOf2(node);
+  }
+  return node;
+}
 function listAllSystems(model) {
   const results = [];
   function walk(map, prefix) {
@@ -585,6 +598,26 @@ var SystemUiSchema = z.object({
   icon: IconNameSchema.optional(),
   order: z.number().int().optional()
 });
+var SystemInterfaceKeySchema = ModelIdSchema;
+var SystemInterfaceLifecycleSchema = z.enum(["draft", "active", "disabled", "deprecated", "archived"]).meta({ label: "System interface lifecycle", color: "teal" });
+var SystemInterfaceReadinessProfileSchema = z.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 = z.array(ModelIdSchema).default([]);
+var SystemApiInterfaceSchema = z.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 = z.object({
+  systemPath: SystemPathSchema,
+  interfaceKey: SystemInterfaceKeySchema
+}).strict();
 var JsonValueSchema = z.lazy(
   () => z.union([
     z.string(),
@@ -623,6 +656,8 @@ var SystemEntrySchema = z.object({
   policies: z.array(ModelIdSchema.meta({ ref: "policy" })).default([]).optional(),
   /** Optional goals this system contributes to. */
   drivesGoals: z.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. */
@@ -889,6 +924,15 @@ var OmTopologyMetadataSchema = z.record(z.string().trim().min(1).max(120), JsonV
   }
   visit(metadata, []);
 });
+var OmTopologySystemInterfaceGrantSchema = z.object({
+  consumer: SystemInterfaceRefSchema,
+  provider: SystemInterfaceRefSchema,
+  resourceIds: z.array(ResourceIdSchema).default([]),
+  ontologyIds: z.array(OntologyIdSchema).default([])
+}).strict();
+z.object({
+  systemInterfaceGrant: OmTopologySystemInterfaceGrantSchema
+}).strict();
 var OmTopologyRelationshipSchema = z.object({
   from: OmTopologyNodeRefSchema,
   kind: OmTopologyRelationshipKindSchema,
@@ -1530,6 +1574,586 @@ function validateModelConfig(config) {
   }
 }
 
+// ../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_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"
+});
+var SystemInterfaceReadinessError = class extends Error {
+  code;
+  statusCode = 503;
+  systemPath;
+  interfaceKey;
+  readinessProfile;
+  issues;
+  constructor(result) {
+    const firstIssue = result.issues[0];
+    super(formatInterfaceReadinessFailure(result));
+    this.name = "SystemInterfaceReadinessError";
+    this.code = firstIssue?.family ?? "SYSTEM_INTERFACE_NOT_READY";
+    this.systemPath = result.systemPath;
+    this.interfaceKey = result.interfaceKey;
+    this.readinessProfile = result.readinessProfile;
+    this.issues = result.issues;
+  }
+};
+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 formatInterfaceReadinessFailure(result) {
+  const identity = formatInterfaceIdentity(result.systemPath, result.interfaceKey);
+  const issueSummary = result.issues.map((issue) => `${issue.family}:${issue.code}: ${issue.message}`).join("; ");
+  return `${identity} readiness failed${result.readinessProfile ? ` (${result.readinessProfile})` : ""}: ${issueSummary}`;
+}
+function throwIfInterfaceNotReady(result) {
+  if (result.ready) return;
+  throw new SystemInterfaceReadinessError(result);
+}
+function getActiveScopedResources(model, resourceIds, issues, context) {
+  const resources = [];
+  for (const [index, resourceId] of resourceIds.entries()) {
+    const resource = model.resources?.[resourceId];
+    const path = `${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, 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, index, objectId, context) {
+  const object = index.ontology.objectTypes[objectId];
+  if (object === 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 = object.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 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 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 requireObjectType(index, objectId, contractId) {
+  if (index.ontology.objectTypes[objectId] === void 0) {
+    throw new Error(`${contractId} is missing required object type: ${objectId}`);
+  }
+}
+function requireCatalog(index, catalogId, contractId) {
+  const catalog = index.ontology.catalogTypes[catalogId];
+  if (catalog === void 0) {
+    throw new Error(`${contractId} is missing required catalog: ${catalogId}`);
+  }
+  return catalog;
+}
+function requireCatalogEntries(catalog, contractId) {
+  if (Object.keys(getCatalogEntries(catalog)).length === 0) {
+    throw new Error(`${contractId} requires catalog entries for ${catalog.id}`);
+  }
+}
+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 requireLeadGenApiReadiness(index) {
+  requireObjectType(index, LEAD_GEN_LIST_OBJECT_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL);
+  requireObjectType(index, LEAD_GEN_COMPANY_OBJECT_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL);
+  requireObjectType(index, LEAD_GEN_CONTACT_OBJECT_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL);
+  requireCatalogEntries(
+    requireCatalog(index, LEAD_GEN_BUILD_TEMPLATE_CATALOG_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL),
+    LEAD_GEN_API_READINESS_LABEL
+  );
+  requireCatalogEntries(
+    requireCatalog(index, LEAD_GEN_COMPANY_STAGE_CATALOG_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL),
+    LEAD_GEN_API_READINESS_LABEL
+  );
+  requireCatalogEntries(
+    requireCatalog(index, LEAD_GEN_CONTACT_STAGE_CATALOG_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL),
+    LEAD_GEN_API_READINESS_LABEL
+  );
+  const templateStepCatalog = findLeadGenTemplateStepCatalog(index);
+  if (templateStepCatalog === void 0) {
+    throw new Error(`${LEAD_GEN_API_READINESS_LABEL} is missing a lead-gen template-step catalog`);
+  }
+  requireCatalogEntries(templateStepCatalog, LEAD_GEN_API_READINESS_LABEL);
+  const leadGenStageCatalog = requireCatalog(index, LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID, LEAD_GEN_API_READINESS_LABEL);
+  requireCatalogEntries(leadGenStageCatalog, LEAD_GEN_API_READINESS_LABEL);
+  return leadGenStageCatalog;
+}
+function requireCrmApiReadiness(index) {
+  const crmPipelineCatalog = requireCatalog(index, CRM_PIPELINE_CATALOG_ONTOLOGY_ID, CRM_API_READINESS_LABEL);
+  requireCatalogEntries(crmPipelineCatalog, CRM_API_READINESS_LABEL);
+  return crmPipelineCatalog;
+}
+function compileBusinessOntologyValidationIndex(model) {
+  throwIfInterfaceNotReady(computeInterfaceReadiness(model, LEAD_GEN_API_INTERFACE));
+  throwIfInterfaceNotReady(computeInterfaceReadiness(model, CRM_API_INTERFACE));
+  const index = compileBusinessOntology(model, "legacy acquisition business ontology");
+  return {
+    ...index,
+    leadGenStageCatalog: requireLeadGenApiReadiness(index),
+    crmPipelineCatalog: requireCrmApiReadiness(index)
+  };
+}
+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 : {};
+}
+function asLeadGenStageEntry(key, value) {
+  const record = isPlainRecord(value) ? value : {};
+  const entity = record.entity === "contact" ? "contact" : "company";
+  const additionalEntities = Array.isArray(record.additionalEntities) ? record.additionalEntities.filter(
+    (item) => item === "company" || item === "contact"
+  ) : void 0;
+  const recordEntity = record.recordEntity === "company" || record.recordEntity === "contact" ? record.recordEntity : void 0;
+  const recordStageKey = typeof record.recordStageKey === "string" ? record.recordStageKey : void 0;
+  return {
+    key: typeof record.key === "string" ? record.key : key,
+    label: typeof record.label === "string" ? record.label : key,
+    description: typeof record.description === "string" ? record.description : "",
+    order: typeof record.order === "number" ? record.order : 0,
+    entity,
+    ...additionalEntities !== void 0 ? { additionalEntities } : {},
+    ...recordEntity !== void 0 ? { recordEntity } : {},
+    ...recordStageKey !== void 0 ? { recordStageKey } : {}
+  };
+}
+function createLeadGenStageValidators(index) {
+  const getCatalog = () => Object.fromEntries(
+    Object.entries(getCatalogEntries(index.leadGenStageCatalog)).map(([key, value]) => [
+      key,
+      asLeadGenStageEntry(key, value)
+    ])
+  );
+  const getEntry = (stageKey) => getCatalog()[stageKey];
+  return {
+    getLeadGenStageCatalog: getCatalog,
+    getLeadGenStageEntry: getEntry,
+    isLeadGenStageKey: (stageKey) => getEntry(stageKey) !== void 0,
+    isLeadGenStageValidForEntity: (stageKey, entity) => {
+      const stage = getEntry(stageKey);
+      return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true);
+    },
+    isLeadGenRecordStageValidForEntity: (stageKey, entity) => {
+      const stage = getEntry(stageKey);
+      return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true || stage.recordEntity === entity);
+    },
+    resolveLeadGenRecordStageKey: (stageKey, entity) => {
+      const stage = getEntry(stageKey);
+      return stage?.recordEntity === entity && stage.recordStageKey ? stage.recordStageKey : stageKey;
+    }
+  };
+}
+
 // ../core/src/platform/registry/validation.ts
 var RegistryValidationError = class extends Error {
   constructor(orgName, resourceId, field, message) {
@@ -1620,7 +2244,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;
@@ -1663,6 +2287,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;
@@ -1777,7 +2440,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);
@@ -1827,6 +2490,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) => {
@@ -1864,6 +2562,7 @@ function validateDeploymentSpec(orgName, resources) {
     }
   });
   validateResourceGovernance(orgName, resources);
+  validateDeclaredSystemInterfaceReadiness(orgName, resources.organizationModel);
 }
 function validateResourceModelConfig(orgName, resourceId, modelConfig) {
   try {
@@ -4690,6 +5389,7 @@ var ResourceRegistry = class {
     const candidate = base ? {
       ...base,
       version: incoming.version ?? base.version ?? "0.0.0",
+      organizationModel: incoming.organizationModel ?? base.organizationModel,
       workflows: [...base.workflows ?? [], ...incoming.workflows ?? []],
       agents: [...base.agents ?? [], ...incoming.agents ?? []],
       triggers: incoming.triggers,
@@ -4851,6 +5551,7 @@ var ResourceRegistry = class {
     }
     const existingOrg = this.registry[orgName];
     if (existingOrg) {
+      existingOrg.organizationModel = org.organizationModel ?? existingOrg.organizationModel;
       existingOrg.workflows = [...existingOrg.workflows ?? [], ...org.workflows ?? []];
       existingOrg.agents = [...existingOrg.agents ?? [], ...org.agents ?? []];
       existingOrg.triggers = org.triggers;
@@ -6119,132 +6820,6 @@ function deriveActions(deal, actions = []) {
   return actions.filter((a) => a.isAvailableFor(deal)).map(({ key, label, payloadSchema }) => ({ key, label, payloadSchema }));
 }
 
-// ../core/src/business/acquisition/ontology-validation.ts
-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 mergeBridgeCatalogs(model) {
-  const baseCatalogTypes = model.ontology?.catalogTypes ?? {};
-  const bridgeCatalogTypes = {};
-  if (baseCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] === void 0) {
-    bridgeCatalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID] = createLeadGenStageCatalog(model);
-  }
-  if (Object.keys(bridgeCatalogTypes).length === 0) return model;
-  return {
-    ...model,
-    ontology: {
-      ...model.ontology ?? {},
-      catalogTypes: {
-        ...baseCatalogTypes,
-        ...bridgeCatalogTypes
-      }
-    }
-  };
-}
-function compileBusinessOntologyValidationIndex(model) {
-  const compilation = compileOrganizationOntology(mergeBridgeCatalogs(model));
-  if (compilation.diagnostics.length > 0) {
-    const summary = compilation.diagnostics.map((diagnostic) => diagnostic.message).join("; ");
-    throw new Error(`Business ontology validation index failed to compile: ${summary}`);
-  }
-  const crmPipelineCatalog = compilation.ontology.catalogTypes[CRM_PIPELINE_CATALOG_ONTOLOGY_ID];
-  const leadGenStageCatalog = compilation.ontology.catalogTypes[LEAD_GEN_STAGE_CATALOG_ONTOLOGY_ID];
-  if (crmPipelineCatalog === void 0 || leadGenStageCatalog === void 0) {
-    throw new Error("Business ontology validation index is missing CRM or lead-gen catalog bridge records");
-  }
-  return {
-    ontology: compilation.ontology,
-    crmPipelineCatalog,
-    leadGenStageCatalog,
-    actionTypesByLegacyId: indexActionTypesByLegacyId(compilation.ontology.actionTypes)
-  };
-}
-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 : {};
-}
-function asLeadGenStageEntry(key, value) {
-  const record = isPlainRecord(value) ? value : {};
-  const entity = record.entity === "contact" ? "contact" : "company";
-  const additionalEntities = Array.isArray(record.additionalEntities) ? record.additionalEntities.filter(
-    (item) => item === "company" || item === "contact"
-  ) : void 0;
-  const recordEntity = record.recordEntity === "company" || record.recordEntity === "contact" ? record.recordEntity : void 0;
-  const recordStageKey = typeof record.recordStageKey === "string" ? record.recordStageKey : void 0;
-  return {
-    key: typeof record.key === "string" ? record.key : key,
-    label: typeof record.label === "string" ? record.label : key,
-    description: typeof record.description === "string" ? record.description : "",
-    order: typeof record.order === "number" ? record.order : 0,
-    entity,
-    ...additionalEntities !== void 0 ? { additionalEntities } : {},
-    ...recordEntity !== void 0 ? { recordEntity } : {},
-    ...recordStageKey !== void 0 ? { recordStageKey } : {}
-  };
-}
-function createLeadGenStageValidators(index) {
-  const getCatalog = () => Object.fromEntries(
-    Object.entries(getCatalogEntries(index.leadGenStageCatalog)).map(([key, value]) => [
-      key,
-      asLeadGenStageEntry(key, value)
-    ])
-  );
-  const getEntry = (stageKey) => getCatalog()[stageKey];
-  return {
-    getLeadGenStageCatalog: getCatalog,
-    getLeadGenStageEntry: getEntry,
-    isLeadGenStageKey: (stageKey) => getEntry(stageKey) !== void 0,
-    isLeadGenStageValidForEntity: (stageKey, entity) => {
-      const stage = getEntry(stageKey);
-      return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true);
-    },
-    isLeadGenRecordStageValidForEntity: (stageKey, entity) => {
-      const stage = getEntry(stageKey);
-      return stage !== void 0 && (stage.entity === entity || stage.additionalEntities?.includes(entity) === true || stage.recordEntity === entity);
-    },
-    resolveLeadGenRecordStageKey: (stageKey, entity) => {
-      const stage = getEntry(stageKey);
-      return stage?.recordEntity === entity && stage.recordStageKey ? stage.recordStageKey : stageKey;
-    }
-  };
-}
-
 // src/project-deployment-spec.ts
 function toSdkResourceDescriptor(resource, getResourceOntologyBinding) {
   const ontologyBinding = getResourceOntologyBinding?.(resource.id);
@@ -6345,4 +6920,4 @@ function projectDeploymentSpec(options) {
 }
 var ListBuilderStageKeySchema = z.string().min(1);
 
-export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ProspectingBuildTemplateSchema as BuildTemplateSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, bindResourceDescriptor, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineStep, defineTopology, defineTopologyRelationship, defineWorkflow, deriveActions, diagnosticOutput, integrationInput, isZodType, parseTopologyNodeRef, projectDeploymentSpec, projectTopologyRelationships, resolveContractRef, runDiagnostic, splitName, toSdkResourceDescriptor, topologyRef, topologyRelationship, validateResourceGovernance, withPlatformIntegrationResourceDescriptor, withPlatformIntegrationResourceDescriptors, withPlatformResourceDescriptor, withPlatformResourceDescriptors };
+export { ActivityEventSchema, BuildPlanSnapshotStepSchema, ProspectingBuildTemplateSchema as BuildTemplateSchema, ContractRefResolutionError, CrmStageKeySchema, CrmStateKeySchema, EmailSchema, ExecutionError, ListBuilderStageKeySchema, ProcessingStageStatusSchema, RegistryValidationError, ResourceRegistry, StepType, ToolingError, bindResourceDescriptor, compileBusinessOntologyValidationIndex, concurrentPool, createLeadGenStageValidators, defineContract, defineResource, defineResourceOntology, defineResources, defineStep, defineTopology, defineTopologyRelationship, defineWorkflow, deriveActions, diagnosticOutput, integrationInput, isZodType, parseTopologyNodeRef, projectDeploymentSpec, projectTopologyRelationships, resolveContractRef, runDiagnostic, splitName, toSdkResourceDescriptor, topologyRef, topologyRelationship, validateDeclaredSystemInterfaceReadiness, validateResourceGovernance, withPlatformIntegrationResourceDescriptor, withPlatformIntegrationResourceDescriptors, withPlatformResourceDescriptor, withPlatformResourceDescriptors };