@inf-monkeys-tech/monkeys 1.1.12 → 1.1.14

package/lib/esm/runtime/index.mjs

@@ -7868,6 +7868,7 @@ var RenderNodeSchema = z3.object({
   semanticRef: EntityRefSchema.optional(),
   dataContextRef: EntityRefSchema.optional(),
   capabilityRef: EntityRefSchema,
+  runtimeContractVersion: ContractIdentifierSchema.optional(),
   providerRef: EntityRefSchema.optional(),
   stateRef: EntityRefSchema.optional(),
   surface: RenderSurfaceSchema,
@@ -8033,6 +8034,7 @@ var ViewProviderDescriptorSchema = z3.object({
   contract: z3.literal("ViewProviderDescriptor"),
   providerId: ContractIdentifierSchema,
   providerVersion: ContractIdentifierSchema,
+  runtimeContractVersion: ContractIdentifierSchema.optional(),
   ownerRepo: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
   rendererKey: ContractIdentifierSchema,
@@ -12327,6 +12329,7 @@ var QueryBindingSchema = z13.object({
   }
 });
 var CapabilityInstanceSchema = z13.object({
+  runtimeContractVersion: ContractIdentifierSchema.optional(),
   instanceId: ContractIdentifierSchema,
   nodeId: ContractIdentifierSchema,
   capabilityRevisionRef: RevisionRefSchema,
@@ -14180,6 +14183,7 @@ var WorkbenchGroupSchema = z13.object({
   accessPolicy: AccessPolicySchema.optional()
 }).strict();
 var WorkbenchAppInstanceSchema = z13.object({
+  runtimeContractVersion: ContractIdentifierSchema.optional(),
   instanceId: ContractIdentifierSchema,
   kind: z13.enum([
     "built-in-application",
@@ -14225,6 +14229,7 @@ var WorkbenchSchema = z13.object({
     showDefaultGroup: z13.boolean()
   }).strict(),
   layout: z13.object({
+    runtimeContractVersion: ContractIdentifierSchema.optional(),
     hostCapabilityRevisionRef: RevisionRefSchema,
     hostProviderRevisionRef: RevisionRefSchema,
     layoutPolicyRevisionRef: RevisionRefSchema,
@@ -15858,6 +15863,7 @@ var DeclarativeCapabilitySchemaDocumentSchema = z15.object({
   }
 });
 var DeclarativeCapabilityAuthoringRegistrationSchema = z15.object({
+  runtimeContractVersion: ContractIdentifierSchema.optional(),
   registrationRevisionRef: RevisionRefSchema,
   capabilityRevisionRef: RevisionRefSchema,
   providerRevisionRef: RevisionRefSchema,
@@ -15984,6 +15990,9 @@ var ProductDeclarativeCapabilityRegistrationSchema = z15.object({
   declarativeRegistration: DeclarativeCapabilityAuthoringRegistrationSchema,
   requiredPermissionCodes: z15.array(ContractIdentifierSchema).default([])
 }).strict().superRefine((value, context) => {
+  if (value.provider.runtimeContractVersion !== value.declarativeRegistration.runtimeContractVersion) {
+    context.addIssue({ code: "custom", path: ["declarativeRegistration", "runtimeContractVersion"], message: "The authoring contract must match its runtime provider." });
+  }
   const ownerRepo = value.manifest.ownerRepo;
   const registration = value.declarativeRegistration;
   if (ownerRepo === "monkeys-design") {
@@ -16498,6 +16507,7 @@ var DeclarativeBindingAuthoringChoiceSchema = DeclarativeAuthoringChoiceSchema.e
   }).strict()
 }).strict();
 var DeclarativeWorkbenchTargetChoiceSchema = z15.object({
+  runtimeContractVersion: ContractIdentifierSchema.optional(),
   stableTargetRef: StableRefSchema,
   targetRevisionRef: RevisionRefSchema,
   providerRevisionRef: RevisionRefSchema,
@@ -17501,6 +17511,7 @@ var stableRefKey = (reference) => `${reference.visibility}:${reference.tenantSco
 var revisionRefKey = (reference) => `${stableRefKey(reference)}@${reference.revision}:v${reference.schemaVersion}:${reference.contentHash.toLowerCase()}`;
 var sameStableRef = (left, right) => stableRefKey(left) === stableRefKey(right);
 var sameRevisionRef = (left, right) => revisionRefKey(left) === revisionRefKey(right);
+var sameSchemaContract = (left, right) => left.kind === "schema" && right.kind === "schema" && sameStableRef(left, right) && left.schemaVersion === right.schemaVersion && left.contentHash === right.contentHash;
 var assertUniqueRegistryKeys = (keys, path) => {
   const seen = /* @__PURE__ */ new Set();
   keys.forEach((key, index) => {
@@ -17770,7 +17781,7 @@ var compileDesignCapabilityCatalogArtifact = (input) => {
       ...unsignedRegistration
     } = registration;
     const registrationHash = canonicalContentHash(unsignedRegistration);
-    if (registration.capabilityRevisionRef.id !== entry.manifest.id || registration.capabilityRevisionRef.ownerRepo !== entry.manifest.ownerRepo || String(registration.capabilityRevisionRef.revision) !== String(entry.manifest.capabilityVersion) || registration.capabilityRevisionRef.contentHash !== canonicalContentHash(entry.manifest) || registration.providerRevisionRef.id !== entry.provider.providerId || registration.providerRevisionRef.ownerRepo !== entry.provider.ownerRepo || String(registration.providerRevisionRef.revision) !== String(entry.provider.providerVersion) || registration.providerRevisionRef.contentHash !== canonicalContentHash(entry.provider) || registration.sourceContentHash !== registrationHash || registration.registrationRevisionRef.contentHash !== registrationHash) {
+    if (registration.runtimeContractVersion !== entry.provider.runtimeContractVersion || registration.capabilityRevisionRef.id !== entry.manifest.id || registration.capabilityRevisionRef.ownerRepo !== entry.manifest.ownerRepo || String(registration.capabilityRevisionRef.revision) !== String(entry.manifest.capabilityVersion) || registration.capabilityRevisionRef.contentHash !== canonicalContentHash(entry.manifest) || registration.providerRevisionRef.id !== entry.provider.providerId || registration.providerRevisionRef.ownerRepo !== entry.provider.ownerRepo || String(registration.providerRevisionRef.revision) !== String(entry.provider.providerVersion) || registration.providerRevisionRef.contentHash !== canonicalContentHash(entry.provider) || registration.sourceContentHash !== registrationHash || registration.registrationRevisionRef.contentHash !== registrationHash) {
       throw new DeclarativeControlCompilationError(
         "DESIGN_CATALOG_INVALID",
         `entries[${index}]`,
@@ -18711,6 +18722,7 @@ var resolvePage = (input) => {
         version: 1,
         ownerRepo: input.pageOwnerRepo
       },
+      ...registration.runtimeContractVersion ? { runtimeContractVersion: registration.runtimeContractVersion } : {},
       capabilityRef: simpleEntityRef(registration.revisionRef),
       providerRef: simpleEntityRef(registration.providerRevisionRef),
       surface: node.surface ?? defaultRenderSurface,
@@ -18725,6 +18737,7 @@ var resolvePage = (input) => {
       ...node.repeat ? { repeat: { ...node.repeat, limit: node.repeat.limit ?? 200 } } : {}
     });
     capabilityInstances.push({
+      ...registration.runtimeContractVersion ? { runtimeContractVersion: registration.runtimeContractVersion } : {},
       instanceId: node.id,
       nodeId: node.id,
       capabilityRevisionRef: registration.revisionRef,
@@ -19274,6 +19287,9 @@ var compilePageRuntimeBundleInternal = (input, legacy) => {
         "Capability/provider pair has no exact governed Design registration."
       );
     }
+    if (instance.runtimeContractVersion !== registration.runtimeContractVersion || node.runtimeContractVersion !== instance.runtimeContractVersion) {
+      throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", `capabilityInstances[${index}].runtimeContractVersion`, "Runtime contract must be issued by the exact governed registration.");
+    }
     if (instance.allowedSideEffects.some(
       (sideEffect) => !registration.allowedSideEffects.includes(sideEffect)
     )) {
@@ -19334,7 +19350,7 @@ var compilePageRuntimeBundleInternal = (input, legacy) => {
     const port = registration?.inputPorts.find(
       (candidate) => candidate.name === binding.target.port
     );
-    if (!port || !sameRevisionRef(
+    if (!port || !sameSchemaContract(
       port.schemaRevisionRef,
       binding.renderModelSchemaRevisionRef
     )) {
@@ -19354,7 +19370,7 @@ var compilePageRuntimeBundleInternal = (input, legacy) => {
       const pageChangePort = sourceRegistration?.outputPorts.find(
         (candidate) => candidate.name === binding.cursorWindow.pageChangePort
       );
-      if (!pageChangePort || !sameRevisionRef(
+      if (!pageChangePort || !sameSchemaContract(
         pageChangePort.schemaRevisionRef,
         binding.cursorWindow.pageChangeIntentSchemaRevisionRef
       )) {
@@ -19376,7 +19392,7 @@ var compilePageRuntimeBundleInternal = (input, legacy) => {
     const port = registration?.inputPorts.find(
       (candidate) => candidate.name === binding.target.port
     );
-    if (!port || !sameRevisionRef(
+    if (!port || !sameSchemaContract(
       port.schemaRevisionRef,
       binding.targetProjection?.schemaRevisionRef ?? binding.renderModelSchemaRevisionRef
     )) {
@@ -19406,7 +19422,7 @@ var compilePageRuntimeBundleInternal = (input, legacy) => {
       const pageChangePort = sourceRegistration?.outputPorts.find(
         (candidate) => candidate.name === binding.cursorWindow.pageChangePort
       );
-      if (!pageChangePort || !sameRevisionRef(
+      if (!pageChangePort || !sameSchemaContract(
         pageChangePort.schemaRevisionRef,
         binding.cursorWindow.pageChangeIntentSchemaRevisionRef
       )) {
@@ -19455,7 +19471,7 @@ var compilePageRuntimeBundleInternal = (input, legacy) => {
     const port = registration?.outputPorts.find(
       (candidate) => candidate.name === binding.source.port
     );
-    if (!port || !sameRevisionRef(
+    if (!port || !sameSchemaContract(
       port.schemaRevisionRef,
       binding.sourceIntentSchemaRevisionRef
     )) {
@@ -19476,7 +19492,7 @@ var compilePageRuntimeBundleInternal = (input, legacy) => {
     const port = registration?.outputPorts.find(
       (candidate) => candidate.name === binding.source.port
     );
-    if (!port || !sameRevisionRef(
+    if (!port || !sameSchemaContract(
       port.schemaRevisionRef,
       binding.sourceIntentSchemaRevisionRef
     )) {
@@ -19799,6 +19815,14 @@ var compileWorkbenchRuntimeBundle = (input) => {
   const groupsById = new Map(
     workbench.groups.map((group) => [group.groupId, group])
   );
+  const contractFor = (capabilityRef, providerRef, declared) => {
+    const registration = input.capabilityRegistry?.find((candidate) => sameRevisionRef(candidate.capabilityRevisionRef, capabilityRef) && sameRevisionRef(candidate.providerRevisionRef, providerRef));
+    if (declared !== void 0 && declared !== registration?.runtimeContractVersion) {
+      throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", "workbench.runtimeContractVersion", "Runtime contract must be issued by the exact governed registration.");
+    }
+    return registration?.runtimeContractVersion;
+  };
+  const layoutContract = contractFor(workbench.layout.hostCapabilityRevisionRef, workbench.layout.hostProviderRevisionRef, workbench.layout.runtimeContractVersion);
   const appInstances = workbench.appInstances.map((instance, index) => {
     const stableTarget = StableRefSchema.parse({
       kind: instance.targetRevisionRef.kind,
@@ -19839,7 +19863,8 @@ var compileWorkbenchRuntimeBundle = (input) => {
         "Workbench and instance audience is wider than the target audience."
       );
     }
-    return { ...instance, targetAccessPolicy: registration.accessPolicy };
+    const runtimeContractVersion = contractFor(instance.targetRevisionRef, instance.providerRevisionRef, instance.runtimeContractVersion);
+    return { ...instance, ...runtimeContractVersion ? { runtimeContractVersion } : {}, targetAccessPolicy: registration.accessPolicy };
   });
   const unsigned = {
     contract: "WorkbenchRuntimeBundle",
@@ -19862,7 +19887,7 @@ var compileWorkbenchRuntimeBundle = (input) => {
     groups: workbench.groups,
     appInstances,
     defaultEntry: workbench.defaultEntry,
-    layout: workbench.layout,
+    layout: { ...workbench.layout, ...layoutContract ? { runtimeContractVersion: layoutContract } : {} },
     workbenchAccessPolicy: workbench.workbenchAccessPolicy,
     personalPreferencesPolicy: workbench.personalPreferencesPolicy,
     target: { ...release.target, routeClaim: releaseRoute },
@@ -24551,6 +24576,213 @@ var compileTenantRuntimeBindings = (config, policy) => {
   });
 };
 
+// src/runtime/declarative-runtime-contract.ts
+var assertViewProviderContract = (node, provider) => {
+  if (node.capabilityRef.kind !== "capability" || node.providerRef?.kind !== "view-provider" || node.capabilityRef.id !== provider.capabilityRef.id || node.capabilityRef.ownerRepo !== provider.capabilityRef.ownerRepo || node.providerRef.id !== provider.providerId || node.providerRef.ownerRepo !== provider.ownerRepo) {
+    throw new TypeError("Runtime capability and provider identities do not match their registered owners.");
+  }
+  if (node.runtimeContractVersion !== void 0) {
+    if (node.runtimeContractVersion !== provider.runtimeContractVersion) {
+      throw new TypeError("The provider does not implement the declared runtime contract.");
+    }
+  } else if (String(node.capabilityRef.version) !== String(provider.capabilityRef.version) || String(node.providerRef.version) !== provider.providerVersion) {
+    throw new TypeError("An unversioned runtime contract requires an exact provider snapshot.");
+  }
+};
+var supportsCapabilityInputSchema = (entry, reference, runtimeContractVersion, portName) => entry.declarativeRegistration.inputPorts.some((port) => (portName === void 0 || port.name === portName) && (sameSchemaContract(port.schemaRevisionRef, reference) || runtimeContractVersion !== void 0 && runtimeContractVersion === entry.provider.runtimeContractVersion && reference.schemaVersion === port.schemaRevisionRef.schemaVersion && sameStableRef(port.schemaRevisionRef, reference)));
+var assertDeclarativeCapabilityContract = (entry, request) => {
+  const registration = entry.declarativeRegistration;
+  if (request.inputSchemaRevisionRef && !supportsCapabilityInputSchema(entry, request.inputSchemaRevisionRef, request.runtimeContractVersion)) {
+    throw new TypeError("The input schema is not owned by the runtime contract.");
+  }
+  if (!sameStableRef(request.capabilityRevisionRef, registration.capabilityRevisionRef) || !sameStableRef(request.providerRevisionRef, registration.providerRevisionRef) || request.capabilityRevisionRef.schemaVersion !== registration.capabilityRevisionRef.schemaVersion || request.providerRevisionRef.schemaVersion !== registration.providerRevisionRef.schemaVersion) {
+    throw new TypeError("Runtime contract snapshots must retain their registered identity, scope and schema version.");
+  }
+  if (request.runtimeContractVersion !== void 0) {
+    if (request.runtimeContractVersion !== entry.provider.runtimeContractVersion || request.propertySchemaRevisionRef && (!sameStableRef(request.propertySchemaRevisionRef, registration.propertySchemaRevisionRef) || request.propertySchemaRevisionRef.schemaVersion !== registration.propertySchemaRevisionRef.schemaVersion)) {
+      throw new TypeError("The capability does not implement the declared runtime contract.");
+    }
+    return;
+  }
+  const capabilityVersion = String(request.capabilityRevisionRef.revision);
+  const providerVersion = String(request.providerRevisionRef.revision);
+  const manifest = {
+    ...entry.manifest,
+    capabilityVersion,
+    runtime: {
+      ...entry.manifest.runtime,
+      providerBindings: entry.manifest.runtime.providerBindings.map((binding) => ({
+        ...binding,
+        providerRef: binding.providerRef.id === entry.provider.providerId ? { ...binding.providerRef, version: providerVersion } : binding.providerRef
+      }))
+    }
+  };
+  const { runtimeContractVersion: _contract, ...descriptor } = entry.provider;
+  const provider = {
+    ...descriptor,
+    providerVersion,
+    capabilityRef: { ...descriptor.capabilityRef, version: capabilityVersion },
+    ...descriptor.sideEffectAdapterRef ? { sideEffectAdapterRef: { ...descriptor.sideEffectAdapterRef, version: capabilityVersion } } : {}
+  };
+  const exact = sameRevisionRef(request.capabilityRevisionRef, registration.capabilityRevisionRef) && sameRevisionRef(request.providerRevisionRef, registration.providerRevisionRef);
+  const equivalent = request.capabilityRevisionRef.contentHash === canonicalContentHash(manifest) && request.providerRevisionRef.contentHash === canonicalContentHash(provider);
+  if (!exact && !equivalent || request.propertySchemaRevisionRef && !sameSchemaContract(request.propertySchemaRevisionRef, registration.propertySchemaRevisionRef)) {
+    throw new TypeError("The historical capability snapshot is not supported by the current runtime contract.");
+  }
+};
+var acceptsPreviousSchema = (previous, next) => {
+  if (canonicalContentHash(previous) === canonicalContentHash(next) || next === true) return true;
+  if (previous === false) return true;
+  if (!previous || !next || typeof previous !== "object" || typeof next !== "object" || Array.isArray(previous) || Array.isArray(next)) return false;
+  const withoutAnnotations = (schema2) => Object.fromEntries(Object.entries(schema2).filter(([key]) => !["title", "description", "examples", "$comment"].includes(key)));
+  const before = withoutAnnotations(previous);
+  const after = withoutAnnotations(next);
+  const {
+    properties: oldProperties,
+    required: oldRequired,
+    additionalProperties: oldAdditional,
+    enum: oldEnum,
+    ...oldFixed
+  } = before;
+  const {
+    properties: newProperties,
+    required: newRequired,
+    additionalProperties: newAdditional,
+    enum: newEnum,
+    ...newFixed
+  } = after;
+  if (canonicalContentHash(oldFixed) !== canonicalContentHash(newFixed)) return false;
+  if (newEnum && (!oldEnum || oldEnum.some((value) => !newEnum.some((candidate) => canonicalContentHash(candidate) === canonicalContentHash(value))))) return false;
+  if ((newRequired ?? []).some((key) => !(oldRequired ?? []).includes(key))) return false;
+  const oldExtra = oldAdditional ?? true;
+  const newExtra = newAdditional ?? true;
+  if (!acceptsPreviousSchema(oldExtra, newExtra)) return false;
+  const keys = /* @__PURE__ */ new Set([...Object.keys(oldProperties ?? {}), ...Object.keys(newProperties ?? {})]);
+  for (const key of keys) {
+    if (!acceptsPreviousSchema(oldProperties?.[key] ?? oldExtra, newProperties?.[key] ?? newExtra)) return false;
+  }
+  return true;
+};
+var assertCompatibleCapabilityUpgrade = (previous, next) => {
+  if (previous.provider.runtimeContractVersion !== void 0 && previous.provider.runtimeContractVersion !== next.provider.runtimeContractVersion || !sameStableRef(previous.declarativeRegistration.capabilityRevisionRef, next.declarativeRegistration.capabilityRevisionRef) || !sameStableRef(previous.declarativeRegistration.providerRevisionRef, next.declarativeRegistration.providerRevisionRef)) {
+    throw new TypeError("A breaking runtime contract requires a new capability/provider identity while the existing contract remains supported.");
+  }
+  const providerContract = (entry) => {
+    const { providerVersion: _revision, capabilityRef, performance: _performance, sideEffectAdapterRef, ...rest } = entry.provider;
+    const { version: _capabilityRevision, ...capability } = capabilityRef;
+    return {
+      ...rest,
+      runtimeContractVersion: next.provider.runtimeContractVersion,
+      capabilityRef: capability,
+      ...sideEffectAdapterRef ? { sideEffectAdapterRef: { ...sideEffectAdapterRef, version: void 0 } } : {}
+    };
+  };
+  if (canonicalContentHash(providerContract(previous)) !== canonicalContentHash(providerContract(next))) {
+    throw new TypeError("A compatible provider upgrade must preserve lifecycle, effects, ownership and public rendering semantics.");
+  }
+  const manifestContract = (entry) => ({
+    kind: entry.manifest.kind,
+    runtime: { ...entry.manifest.runtime, providerBindings: entry.manifest.runtime.providerBindings.map((binding) => ({ ...binding, providerRef: { ...binding.providerRef, version: void 0 } })) },
+    placement: entry.manifest.placement,
+    accessibility: entry.manifest.accessibility
+  });
+  if (canonicalContentHash(manifestContract(previous)) !== canonicalContentHash(manifestContract(next))) {
+    throw new TypeError("Capability behavior, placement and access semantics must preserve the published runtime contract.");
+  }
+  const oldRegistration = previous.declarativeRegistration;
+  const newRegistration = next.declarativeRegistration;
+  const schema2 = (entry, reference) => {
+    const document = entry.schemaDocuments.find((candidate) => sameSchemaContract(candidate.schemaRevisionRef, reference));
+    if (!document || canonicalContentHash(document.document) !== reference.contentHash) throw new TypeError("Runtime contract schema integrity failed.");
+    return document.document;
+  };
+  const checkSchema = (oldRef, newRef, output = false) => {
+    if (!sameStableRef(oldRef, newRef) || oldRef.schemaVersion !== newRef.schemaVersion || !acceptsPreviousSchema(
+      schema2(output ? newRegistration : oldRegistration, output ? newRef : oldRef),
+      schema2(output ? oldRegistration : newRegistration, output ? oldRef : newRef)
+    )) {
+      throw new TypeError(`Schema ${oldRef.id} breaks the published runtime contract.`);
+    }
+  };
+  checkSchema(oldRegistration.propertySchemaRevisionRef, newRegistration.propertySchemaRevisionRef);
+  for (const direction of ["inputPorts", "outputPorts"]) {
+    const oldPorts = oldRegistration[direction];
+    const newPorts = newRegistration[direction];
+    const oldManifestPorts = previous.manifest.ports?.[direction === "inputPorts" ? "inputs" : "outputs"] ?? [];
+    const newManifestPorts = next.manifest.ports?.[direction === "inputPorts" ? "inputs" : "outputs"] ?? [];
+    for (const port of oldManifestPorts) {
+      const replacement = newManifestPorts.find((candidate) => candidate.name === port.name);
+      if (!replacement || canonicalContentHash(port) !== canonicalContentHash(replacement)) throw new TypeError("Published runtime port semantics changed.");
+    }
+    if (newManifestPorts.some((port) => port.required && !oldManifestPorts.some((previousPort) => previousPort.name === port.name)) || newPorts.some((port) => port.required && !oldPorts.some((previousPort) => previousPort.name === port.name))) {
+      throw new TypeError("New runtime ports must be optional for published declarations.");
+    }
+    for (const port of oldPorts) {
+      const replacement = newPorts.find((candidate) => candidate.name === port.name);
+      if (!replacement || port.required !== replacement.required || port.multiple !== replacement.multiple) throw new TypeError("Public runtime port cardinality changed.");
+      checkSchema(port.schemaRevisionRef, replacement.schemaRevisionRef, direction === "outputPorts");
+    }
+  }
+  const requirements = (entry) => entry.ontologyRequirements.map((requirement) => {
+    const { revision: _revision, contentHash: _hash, ...schema3 } = requirement.renderModelSchemaRevisionRef;
+    return { ...requirement, renderModelSchemaRevisionRef: schema3 };
+  });
+  if (canonicalContentHash(requirements(oldRegistration)) !== canonicalContentHash(requirements(newRegistration))) {
+    throw new TypeError("Runtime Ontology access requirements changed.");
+  }
+  const existingOutputs = new Set(oldRegistration.outputPorts.map((port) => port.name));
+  const existingActions = newRegistration.actionRequirements.filter((requirement) => existingOutputs.has(requirement.outputPort));
+  if (canonicalContentHash(oldRegistration.actionRequirements) !== canonicalContentHash(existingActions)) {
+    throw new TypeError("Published output action and permission requirements changed.");
+  }
+  for (const key of ["allowedSideEffects", "allowedSlots", "supportedSurfaces", "allowedParentCapabilityRefs", "allowedChildCapabilityRefs"]) {
+    if (canonicalContentHash(oldRegistration[key]) !== canonicalContentHash(newRegistration[key])) throw new TypeError(`Runtime contract ${key} changed.`);
+  }
+};
+var projectRuntimeContracts = (bundle, entries) => {
+  const resolve = (request) => {
+    if (request.runtimeContractVersion) return request.runtimeContractVersion;
+    const candidates = entries.filter((entry) => sameStableRef(entry.declarativeRegistration.capabilityRevisionRef, request.capabilityRevisionRef) && sameStableRef(entry.declarativeRegistration.providerRevisionRef, request.providerRevisionRef));
+    const current = [...candidates].sort((a, b) => b.declarativeRegistration.capabilityRevisionRef.revision - a.declarativeRegistration.capabilityRevisionRef.revision || b.declarativeRegistration.registrationRevisionRef.revision - a.declarativeRegistration.registrationRevisionRef.revision || Number(Boolean(b.provider.runtimeContractVersion)) - Number(Boolean(a.provider.runtimeContractVersion)))[0];
+    if (!current?.provider.runtimeContractVersion) return void 0;
+    try {
+      assertDeclarativeCapabilityContract(current, request);
+      return current.provider.runtimeContractVersion;
+    } catch {
+      const historical = candidates.find((entry) => sameRevisionRef(entry.declarativeRegistration.capabilityRevisionRef, request.capabilityRevisionRef) && sameRevisionRef(entry.declarativeRegistration.providerRevisionRef, request.providerRevisionRef));
+      if (!historical) return void 0;
+      try {
+        assertDeclarativeCapabilityContract(historical, request);
+        assertCompatibleCapabilityUpgrade(historical, current);
+        return current.provider.runtimeContractVersion;
+      } catch {
+        return void 0;
+      }
+    }
+  };
+  const projected = structuredClone(bundle);
+  if (projected.contract === "PageRuntimeBundle") {
+    for (const instance of projected.capabilityInstances) {
+      const contract = resolve(instance);
+      if (!contract) continue;
+      const node = projected.renderTree.nodes.find((node2) => node2.nodeId === instance.nodeId);
+      if (!node || String(node.providerRef?.version) !== String(instance.providerRevisionRef.revision) || String(node.capabilityRef.version) !== String(instance.capabilityRevisionRef.revision) || node.providerRef?.id !== instance.providerRevisionRef.id || node.capabilityRef.id !== instance.capabilityRevisionRef.id) continue;
+      instance.runtimeContractVersion = contract;
+      node.runtimeContractVersion = contract;
+    }
+  } else {
+    for (const instance of projected.appInstances) {
+      const contract2 = resolve({ capabilityRevisionRef: instance.targetRevisionRef, providerRevisionRef: instance.providerRevisionRef, inputSchemaRevisionRef: instance.inputSchemaRevisionRef, runtimeContractVersion: instance.runtimeContractVersion });
+      if (contract2) instance.runtimeContractVersion = contract2;
+    }
+    const contract = resolve({ capabilityRevisionRef: projected.layout.hostCapabilityRevisionRef, providerRevisionRef: projected.layout.hostProviderRevisionRef, runtimeContractVersion: projected.layout.runtimeContractVersion });
+    if (contract) projected.layout.runtimeContractVersion = contract;
+  }
+  const { contentHash: _hash, ...unsigned } = projected;
+  projected.contentHash = canonicalContentHash(unsigned);
+  return projected;
+};
+
 // src/runtime/view-render-model.ts
 var DEFAULT_FORBIDDEN_RENDER_MODEL_KEYS = Object.freeze([
   "tenant",
@@ -25610,12 +25842,16 @@ export {
   NAVIGATION_UNAVAILABLE_CAPABILITY_HEADER,
   PageStreamReducerError,
   ThemeTokenValidationError,
+  acceptsPreviousSchema,
   accessPolicyChainImplies,
   applyPageStreamEvent,
   applyRecordEditorDraft,
   applyViewRuntimeBindings,
+  assertCompatibleCapabilityUpgrade,
+  assertDeclarativeCapabilityContract,
   assertMonkeysThemeTokensComplete,
   assertThemeTokensDocumentStructure,
+  assertViewProviderContract,
   buildApplicationHandoffUrl,
   buildChangeImpactGraph,
   canonicalContentHash,
@@ -25684,6 +25920,7 @@ export {
   projectNavigationCompatibility,
   projectPageProperties,
   projectRecordEditorValidation,
+  projectRuntimeContracts,
   publishOpenApiToolCapabilityManifests,
   readApplicationHandoffFromUrl,
   readMenuActivationFromSearch,
@@ -25700,10 +25937,12 @@ export {
   resolveWorkflowColumnResult,
   revisionRefKey,
   sameRevisionRef,
+  sameSchemaContract,
   sameStableRef,
   serializeApplicationHandoff,
   serializeMenuActivationSearch,
   stableRefKey,
+  supportsCapabilityInputSchema,
   toAgentSessionViewModel,
   validateDomainCommand,
   validateThemeTokensDocument,