@inf-monkeys-tech/monkeys 1.0.72 → 1.1.1

package/lib/runtime/declarative-control-compiler.js

@@ -1,21 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveWorkbenchEntry = exports.validateWorkbenchRuntimeSet = exports.compileNavigationRuntimeBundle = exports.compileWorkbenchRuntimeBundle = exports.compilePageRuntimeBundle = exports.materializeRouteSpacePath = exports.compileRouteClaims = exports.accessPolicyChainImplies = exports.declarativeProductResourceRevisionHash = exports.declarativeProductResourceSourceHash = exports.declarativeRouteSpaceRevisionHash = exports.declarativeRouteSpaceSourceHash = exports.declarativeCreateTemplateRevisionHash = exports.declarativeCreateTemplateSourceHash = exports.canonicalContentHash = exports.sameRevisionRef = exports.sameStableRef = exports.revisionRefKey = exports.stableRefKey = exports.DeclarativeControlCompilationError = void 0;
+exports.resolveWorkbenchEntry = exports.validateWorkbenchRuntimeSet = exports.compileNavigationRuntimeBundle = exports.compileWorkbenchRuntimeBundle = exports.compilePageRuntimeBundle = exports.resolvePage = exports.materializeRouteSpacePath = exports.matchCompiledRouteClaim = exports.compileRouteClaims = exports.compiledRouteClaimsOverlap = exports.accessPolicyChainImplies = exports.parseExactDesignCapabilityCatalogArtifact = exports.parseExactProductDeclarativeCapabilityRegistration = exports.compileDesignCapabilityCatalogArtifact = exports.designCapabilityCatalogArtifactHash = exports.declarativeProductResourceRevisionHash = exports.declarativeProductResourceSourceHash = exports.declarativeRouteSpaceRevisionHash = exports.declarativeRouteSpaceSourceHash = exports.declarativeCreateTemplateRevisionHash = exports.declarativeCreateTemplateSourceHash = exports.compileDeclarativeWorkbenchCatalog = exports.compileDeclarativeRouteOwnerIndex = exports.permissionAlternativePolicyAllows = exports.parseExactLegacyRouteTakeoverAuthorization = exports.legacyRouteTakeoverAuthorizationHash = exports.compileLegacyRouteTakeoverAuthorization = exports.declarativeWorkbenchCatalogProjectionId = exports.declarativeRouteOwnerIndexProjectionId = exports.declarativeRuntimeProjectionId = exports.canonicalContentHash = exports.sameRevisionRef = exports.sameStableRef = exports.revisionRefKey = exports.stableRefKey = exports.DeclarativeControlCompilationError = void 0;
 const common_1 = require("../contracts/common");
+const declarative_control_http_1 = require("../contracts/declarative-control-http");
 const render_tree_compiler_1 = require("./render-tree-compiler");
+const page_expression_1 = require("../contracts/page-expression");
 const declarative_control_1 = require("../contracts/declarative-control");
 class DeclarativeControlCompilationError extends Error {
     constructor(code, path, message) {
         super(`${code} at ${path}: ${message}`);
         this.code = code;
         this.path = path;
-        this.name = 'DeclarativeControlCompilationError';
+        this.name = "DeclarativeControlCompilationError";
     }
 }
 exports.DeclarativeControlCompilationError = DeclarativeControlCompilationError;
 const scopedIdentityKey = (reference) => `${reference.kind}:${reference.id}:${reference.ownerRepo}`;
-const scopeKey = (scope) => `${scopedIdentityKey(scope.tenantRef)}:${scopedIdentityKey(scope.dataSpaceRef)}:${scope.teamRef ? scopedIdentityKey(scope.teamRef) : ''}`;
-const stableRefKey = (reference) => `${reference.visibility}:${reference.tenantScope ? scopeKey(reference.tenantScope) : ''}:${reference.kind}:${reference.id}:${reference.ownerRepo}`;
+const scopeKey = (scope) => `${scopedIdentityKey(scope.tenantRef)}:${scopedIdentityKey(scope.dataSpaceRef)}:${scope.teamRef ? scopedIdentityKey(scope.teamRef) : ""}`;
+const stableRefKey = (reference) => `${reference.visibility}:${reference.tenantScope ? scopeKey(reference.tenantScope) : ""}:${reference.kind}:${reference.id}:${reference.ownerRepo}`;
 exports.stableRefKey = stableRefKey;
 const revisionRefKey = (reference) => `${(0, exports.stableRefKey)(reference)}@${reference.revision}:v${reference.schemaVersion}:${reference.contentHash.toLowerCase()}`;
 exports.revisionRefKey = revisionRefKey;
@@ -27,38 +29,41 @@ const assertUniqueRegistryKeys = (keys, path) => {
     const seen = new Set();
     keys.forEach((key, index) => {
         if (seen.has(key)) {
-            throw new DeclarativeControlCompilationError('REGISTRY_CONFLICT', `${path}[${index}]`, `Duplicate registry identity: ${key}`);
+            throw new DeclarativeControlCompilationError("REGISTRY_CONFLICT", `${path}[${index}]`, `Duplicate registry identity: ${key}`);
         }
         seen.add(key);
     });
 };
 const stableSerialize = (value) => {
     if (value === undefined)
-        return 'null';
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value) ?? 'null';
+        return "null";
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value) ?? "null";
     if (Array.isArray(value))
-        return `[${value.map((item) => stableSerialize(item)).join(',')}]`;
+        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
     const record = value;
     return `{${Object.keys(record)
         .filter((key) => record[key] !== undefined)
         .sort()
         .map((key) => `${JSON.stringify(key)}:${stableSerialize(record[key])}`)
-        .join(',')}}`;
+        .join(",")}}`;
 };
 const SHA256_INITIAL = [
-    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
-    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+    0x1f83d9ab, 0x5be0cd19,
 ];
 const SHA256_ROUND = [
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
 ];
 const rotateRight = (value, amount) => (value >>> amount) | (value << (32 - amount));
 const sha256Hex = (value) => {
@@ -78,14 +83,20 @@ const sha256Hex = (value) => {
     for (let offset = 0; offset < source.length; offset += 64) {
         for (let index = 0; index < 16; index += 1) {
             const start = offset + index * 4;
-            words[index] = ((source[start] << 24) | (source[start + 1] << 16) | (source[start + 2] << 8) | source[start + 3]) >>> 0;
+            words[index] =
+                ((source[start] << 24) |
+                    (source[start + 1] << 16) |
+                    (source[start + 2] << 8) |
+                    source[start + 3]) >>>
+                    0;
         }
         for (let index = 16; index < 64; index += 1) {
             const previous = words[index - 15];
             const recent = words[index - 2];
             const small0 = rotateRight(previous, 7) ^ rotateRight(previous, 18) ^ (previous >>> 3);
             const small1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ (recent >>> 10);
-            words[index] = (words[index - 16] + small0 + words[index - 7] + small1) >>> 0;
+            words[index] =
+                (words[index - 16] + small0 + words[index - 7] + small1) >>> 0;
         }
         let [a, b, c, d, e, f, g, h] = hash;
         for (let index = 0; index < 64; index += 1) {
@@ -113,10 +124,113 @@ const sha256Hex = (value) => {
         hash[6] = (hash[6] + g) >>> 0;
         hash[7] = (hash[7] + h) >>> 0;
     }
-    return hash.map((part) => part.toString(16).padStart(8, '0')).join('');
+    return hash.map((part) => part.toString(16).padStart(8, "0")).join("");
 };
 const canonicalContentHash = (value) => sha256Hex(stableSerialize(value));
 exports.canonicalContentHash = canonicalContentHash;
+/**
+ * Names one immutable Runtime Bundle projection by its exact Release evidence.
+ * The fixed-size digest stays below Data Server's 256-byte projection id limit
+ * even when a governed release slot uses the maximum contract identifier size.
+ */
+const declarativeRuntimeProjectionId = (resourceKind, releaseSlotId, releaseRevisionRef) => `drb:${(0, exports.canonicalContentHash)({ resourceKind, releaseSlotId, releaseRevisionRef })}`;
+exports.declarativeRuntimeProjectionId = declarativeRuntimeProjectionId;
+/** Names the rebuildable route-owner index for one tenant environment surface. */
+const declarativeRouteOwnerIndexProjectionId = (tenantScope, environmentRef, surface) => `dri:${(0, exports.canonicalContentHash)({
+    tenantScope: {
+        teamRef: tenantScope.teamRef
+            ? { kind: tenantScope.teamRef.kind, id: tenantScope.teamRef.id }
+            : null,
+    },
+    environmentRef,
+    surface,
+})}`;
+exports.declarativeRouteOwnerIndexProjectionId = declarativeRouteOwnerIndexProjectionId;
+const declarativeWorkbenchCatalogProjectionId = (tenantScope, environmentRef, surface) => `dwc:${(0, exports.canonicalContentHash)({
+    tenantScope: {
+        teamRef: tenantScope.teamRef
+            ? { kind: tenantScope.teamRef.kind, id: tenantScope.teamRef.id }
+            : null,
+    },
+    environmentRef,
+    surface,
+})}`;
+exports.declarativeWorkbenchCatalogProjectionId = declarativeWorkbenchCatalogProjectionId;
+const takeoverHashSource = (authorization) => authorization;
+const compileLegacyRouteTakeoverAuthorization = (input) => {
+    const unsigned = {
+        ...input,
+        contract: "LegacyRouteTakeoverAuthorization",
+        schemaVersion: 1,
+    };
+    return deepFreeze(declarative_control_1.LegacyRouteTakeoverAuthorizationSchema.parse({
+        ...unsigned,
+        contentHash: (0, exports.canonicalContentHash)(takeoverHashSource(unsigned)),
+    }));
+};
+exports.compileLegacyRouteTakeoverAuthorization = compileLegacyRouteTakeoverAuthorization;
+const legacyRouteTakeoverAuthorizationHash = (input) => (0, exports.canonicalContentHash)(takeoverHashSource(input));
+exports.legacyRouteTakeoverAuthorizationHash = legacyRouteTakeoverAuthorizationHash;
+const parseExactLegacyRouteTakeoverAuthorization = (input) => {
+    const parsed = declarative_control_1.LegacyRouteTakeoverAuthorizationSchema.parse(input);
+    const { contentHash, ...unsigned } = parsed;
+    if (contentHash !== (0, exports.legacyRouteTakeoverAuthorizationHash)(unsigned)) {
+        throw new DeclarativeControlCompilationError("ROUTE_TAKEOVER_INVALID", "contentHash", "Legacy route takeover authorization content hash is not exact.");
+    }
+    return deepFreeze(parsed);
+};
+exports.parseExactLegacyRouteTakeoverAuthorization = parseExactLegacyRouteTakeoverAuthorization;
+const permissionAlternativePolicyAllows = (policyInput, permissionCodes) => {
+    const parsed = declarative_control_1.PermissionAlternativePolicySchema.parse(policyInput);
+    const available = permissionCodes instanceof Set ? permissionCodes : new Set(permissionCodes);
+    return parsed.alternatives.some((alternative) => alternative.every((permission) => available.has(permission)));
+};
+exports.permissionAlternativePolicyAllows = permissionAlternativePolicyAllows;
+const compileDeclarativeRouteOwnerIndex = (input) => {
+    const entries = input.entries
+        .map((entry) => ({ ...entry }))
+        .sort((left, right) => {
+        const leftKey = `${left.resourceKind}:${left.releaseSlotId}`;
+        const rightKey = `${right.resourceKind}:${right.releaseSlotId}`;
+        return leftKey.localeCompare(rightKey);
+    });
+    const unsigned = {
+        contract: "DeclarativeRouteOwnerIndex",
+        schemaVersion: 1,
+        tenantScope: declarative_control_1.TenantScopeSchema.parse(input.tenantScope),
+        environmentRef: declarative_control_1.StableRefSchema.parse(input.environmentRef),
+        surface: input.surface,
+        generation: input.generation,
+        entries,
+        rebuildable: true,
+    };
+    return deepFreeze(declarative_control_1.DeclarativeRouteOwnerIndexSchema.parse({
+        ...unsigned,
+        contentHash: (0, exports.canonicalContentHash)(unsigned),
+    }));
+};
+exports.compileDeclarativeRouteOwnerIndex = compileDeclarativeRouteOwnerIndex;
+const compileDeclarativeWorkbenchCatalog = (input) => {
+    const entries = input.entries
+        .map((entry) => ({ ...entry }))
+        .sort((left, right) => left.order - right.order ||
+        left.workbenchId.localeCompare(right.workbenchId));
+    const unsigned = {
+        contract: "DeclarativeWorkbenchCatalog",
+        schemaVersion: 1,
+        tenantScope: declarative_control_1.TenantScopeSchema.parse(input.tenantScope),
+        environmentRef: declarative_control_1.StableRefSchema.parse(input.environmentRef),
+        surface: input.surface,
+        generation: input.generation,
+        entries,
+        rebuildable: true,
+    };
+    return deepFreeze(declarative_control_1.DeclarativeWorkbenchCatalogSchema.parse({
+        ...unsigned,
+        contentHash: (0, exports.canonicalContentHash)(unsigned),
+    }));
+};
+exports.compileDeclarativeWorkbenchCatalog = compileDeclarativeWorkbenchCatalog;
 const declarativeCreateTemplateSourceHash = (document) => (0, exports.canonicalContentHash)(document);
 exports.declarativeCreateTemplateSourceHash = declarativeCreateTemplateSourceHash;
 const declarativeCreateTemplateRevisionHash = (registration) => (0, exports.canonicalContentHash)(registration.document);
@@ -129,20 +243,124 @@ const declarativeProductResourceSourceHash = (document) => (0, exports.canonical
 exports.declarativeProductResourceSourceHash = declarativeProductResourceSourceHash;
 const declarativeProductResourceRevisionHash = (registration) => (0, exports.canonicalContentHash)(registration.document);
 exports.declarativeProductResourceRevisionHash = declarativeProductResourceRevisionHash;
+const designCapabilityCatalogHashSource = (input) => ({
+    contract: "DesignCapabilityCatalogArtifact",
+    schemaVersion: 1,
+    sourceRef: input.sourceRef,
+    entries: input.entries,
+});
+const designCapabilityCatalogArtifactHash = (input) => (0, exports.canonicalContentHash)(designCapabilityCatalogHashSource(input));
+exports.designCapabilityCatalogArtifactHash = designCapabilityCatalogArtifactHash;
+const compileDesignCapabilityCatalogArtifact = (input) => {
+    const entries = input.entries
+        .map((entry) => ({ ...entry }))
+        .sort((left, right) => left.manifest.id.localeCompare(right.manifest.id));
+    entries.forEach((entry, index) => {
+        const registration = entry.declarativeRegistration;
+        const { registrationRevisionRef: _registrationRevisionRef, sourceContentHash: _sourceContentHash, ...unsignedRegistration } = registration;
+        const registrationHash = (0, exports.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 !==
+                (0, exports.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 !==
+                (0, exports.canonicalContentHash)(entry.provider) ||
+            registration.sourceContentHash !== registrationHash ||
+            registration.registrationRevisionRef.contentHash !== registrationHash) {
+            throw new DeclarativeControlCompilationError("DESIGN_CATALOG_INVALID", `entries[${index}]`, "Design capability manifest, provider and authoring registration are not exact.");
+        }
+        registration.schemaDocuments.forEach((schema, schemaIndex) => {
+            if (schema.schemaRevisionRef.ownerRepo !== "monkeys-design" ||
+                schema.schemaRevisionRef.visibility !== "global" ||
+                schema.schemaRevisionRef.contentHash !==
+                    (0, exports.canonicalContentHash)(schema.document)) {
+                throw new DeclarativeControlCompilationError("DESIGN_CATALOG_INVALID", `entries[${index}].declarativeRegistration.schemaDocuments[${schemaIndex}]`, "Design Schema documents require exact global monkeys-design authority.");
+            }
+        });
+    });
+    const sourceContentHash = (0, exports.designCapabilityCatalogArtifactHash)({
+        sourceRef: input.sourceRef,
+        entries,
+    });
+    const sourceRevisionRef = declarative_control_1.RevisionRefSchema.parse({
+        kind: "design-capability-catalog",
+        id: input.sourceRef,
+        ownerRepo: "monkeys-design",
+        visibility: "global",
+        revision: input.revision,
+        schemaVersion: 1,
+        contentHash: sourceContentHash,
+    });
+    return deepFreeze(declarative_control_http_1.DesignCapabilityCatalogArtifactSchema.parse({
+        contract: "DesignCapabilityCatalogArtifact",
+        schemaVersion: 1,
+        sourceRef: input.sourceRef,
+        sourceRevisionRef,
+        entries,
+        sourceContentHash,
+    }));
+};
+exports.compileDesignCapabilityCatalogArtifact = compileDesignCapabilityCatalogArtifact;
+/** Validate immutable product-owned capability provenance from an application release. */
+const parseExactProductDeclarativeCapabilityRegistration = (input) => {
+    const entry = declarative_control_http_1.ProductDeclarativeCapabilityRegistrationSchema.parse(input);
+    const registration = entry.declarativeRegistration;
+    const { registrationRevisionRef: _registrationRevisionRef, sourceContentHash: _sourceContentHash, ...unsignedRegistration } = registration;
+    if (registration.capabilityRevisionRef.contentHash !==
+        (0, exports.canonicalContentHash)(entry.manifest) ||
+        registration.providerRevisionRef.contentHash !==
+            (0, exports.canonicalContentHash)(entry.provider) ||
+        registration.sourceContentHash !==
+            (0, exports.canonicalContentHash)(unsignedRegistration) ||
+        registration.registrationRevisionRef.contentHash !==
+            registration.sourceContentHash) {
+        throw new DeclarativeControlCompilationError("PRODUCT_CAPABILITY_CATALOG_INVALID", "declarativeRegistration", "Product capability manifest, provider and authoring registration are not exact.");
+    }
+    registration.schemaDocuments.forEach((schema, schemaIndex) => {
+        if (schema.schemaRevisionRef.contentHash !==
+            (0, exports.canonicalContentHash)(schema.document)) {
+            throw new DeclarativeControlCompilationError("PRODUCT_CAPABILITY_CATALOG_INVALID", `declarativeRegistration.schemaDocuments[${schemaIndex}]`, "Product capability Schema document does not match its exact RevisionRef.");
+        }
+    });
+    return deepFreeze(entry);
+};
+exports.parseExactProductDeclarativeCapabilityRegistration = parseExactProductDeclarativeCapabilityRegistration;
+const parseExactDesignCapabilityCatalogArtifact = (input) => {
+    const parsed = declarative_control_http_1.DesignCapabilityCatalogArtifactSchema.parse(input);
+    const expected = (0, exports.compileDesignCapabilityCatalogArtifact)({
+        sourceRef: parsed.sourceRef,
+        revision: parsed.sourceRevisionRef.revision,
+        entries: parsed.entries,
+    });
+    if (parsed.sourceContentHash !== expected.sourceContentHash ||
+        !(0, exports.sameRevisionRef)(parsed.sourceRevisionRef, expected.sourceRevisionRef)) {
+        throw new DeclarativeControlCompilationError("DESIGN_CATALOG_INVALID", "sourceRevisionRef", "Design capability catalog artifact provenance or content hash is not exact.");
+    }
+    return deepFreeze(parsed);
+};
+exports.parseExactDesignCapabilityCatalogArtifact = parseExactDesignCapabilityCatalogArtifact;
 const deepFreeze = (value) => {
-    if (value === null || typeof value !== 'object' || Object.isFrozen(value))
+    if (value === null || typeof value !== "object" || Object.isFrozen(value))
         return value;
     Object.values(value).forEach((child) => deepFreeze(child));
     return Object.freeze(value);
 };
 const assertTenantCompatible = (reference, scope, path) => {
-    if (reference.visibility === 'tenant' && scopeKey(reference.tenantScope) !== scopeKey(scope)) {
-        throw new DeclarativeControlCompilationError('CROSS_TENANT_REFERENCE', path, `Reference ${reference.kind}/${reference.id} belongs to another tenant scope.`);
+    if (reference.visibility === "tenant" &&
+        scopeKey(reference.tenantScope) !== scopeKey(scope)) {
+        throw new DeclarativeControlCompilationError("CROSS_TENANT_REFERENCE", path, `Reference ${reference.kind}/${reference.id} belongs to another tenant scope.`);
     }
 };
 const assertSameTenantScope = (candidate, expected, path) => {
     if (scopeKey(candidate) !== scopeKey(expected)) {
-        throw new DeclarativeControlCompilationError('CROSS_TENANT_REFERENCE', path, 'Record and release tenant scopes do not match.');
+        throw new DeclarativeControlCompilationError("CROSS_TENANT_REFERENCE", path, "Record and release tenant scopes do not match.");
     }
 };
 const stableFromRevision = (reference) => declarative_control_1.StableRefSchema.parse({
@@ -154,7 +372,7 @@ const stableFromRevision = (reference) => declarative_control_1.StableRefSchema.
 });
 const assertRevisionIdentity = (reference, expectedKind, expectedId, scope, path) => {
     if (reference.kind !== expectedKind || reference.id !== expectedId) {
-        throw new DeclarativeControlCompilationError('REVISION_MISMATCH', path, `Expected ${expectedKind}/${expectedId}, received ${reference.kind}/${reference.id}.`);
+        throw new DeclarativeControlCompilationError("REVISION_MISMATCH", path, `Expected ${expectedKind}/${expectedId}, received ${reference.kind}/${reference.id}.`);
     }
     assertTenantCompatible(reference, scope, path);
 };
@@ -164,22 +382,33 @@ const requireDependencies = (snapshot, required) => {
     for (const dependency of required) {
         const key = dependencyKey(dependency.role, dependency.revisionRef);
         if (!available.has(key)) {
-            throw new DeclarativeControlCompilationError('DEPENDENCY_MISSING', 'dependencySnapshot', `Missing exact ${dependency.role} dependency ${(0, exports.revisionRefKey)(dependency.revisionRef)}.`);
+            throw new DeclarativeControlCompilationError("DEPENDENCY_MISSING", "dependencySnapshot", `Missing exact ${dependency.role} dependency ${(0, exports.revisionRefKey)(dependency.revisionRef)}.`);
         }
     }
 };
 const assertDependencyScopes = (snapshot, scope) => snapshot.forEach((dependency, index) => assertTenantCompatible(dependency.revisionRef, scope, `dependencySnapshot[${index}].revisionRef`));
 const requireReleaseReady = (release) => {
-    if (release.evidence.validation.result !== 'pass') {
-        throw new DeclarativeControlCompilationError('RELEASE_VALIDATION_FAILED', 'evidence.validation.result', 'Runtime bundles require a passing release validation result.');
+    if (release.operation === "deactivate") {
+        throw new DeclarativeControlCompilationError("RELEASE_OPERATION_INVALID", "operation", "A deactivation Release cannot produce an active runtime bundle.");
+    }
+    if (release.evidence.validation.result !== "pass") {
+        throw new DeclarativeControlCompilationError("RELEASE_VALIDATION_FAILED", "evidence.validation.result", "Runtime bundles require a passing release validation result.");
     }
 };
 const refSet = (values) => new Set(values.map(exports.stableRefKey));
 const chainRequiresAll = (policies, field) => {
-    if (field === 'permissionAllOf')
-        return new Set(policies.flatMap((policy) => policy.permissionAllOf));
-    if (field === 'groupAllOf')
-        return refSet(policies.flatMap((policy) => policy.groupAllOf));
+    if (field === "permissionAllOf") {
+        return new Set(policies.flatMap((policy) => [
+            ...policy.permissionAllOf,
+            ...(policy.permissionAnyOf.length === 1 ? policy.permissionAnyOf : []),
+        ]));
+    }
+    if (field === "groupAllOf") {
+        return refSet(policies.flatMap((policy) => [
+            ...policy.groupAllOf,
+            ...(policy.groupAnyOf.length === 1 ? policy.groupAnyOf : []),
+        ]));
+    }
     return new Set(policies.flatMap((policy) => policy.conditionAllOf.map(exports.revisionRefKey)));
 };
 const chainImpliesAny = (policies, targetAny, allValues, anyValues) => {
@@ -197,17 +426,17 @@ const accessPolicyChainImplies = (policyInputs, targetInput) => {
     const target = declarative_control_1.AccessPolicySchema.parse(targetInput);
     if (target.authenticated && !policies.some((policy) => policy.authenticated))
         return false;
-    const permissionAll = chainRequiresAll(policies, 'permissionAllOf');
+    const permissionAll = chainRequiresAll(policies, "permissionAllOf");
     if (target.permissionAllOf.some((permission) => !permissionAll.has(permission)))
         return false;
     if (!chainImpliesAny(policies, new Set(target.permissionAnyOf), permissionAll, (policy) => policy.permissionAnyOf))
         return false;
-    const groupAll = chainRequiresAll(policies, 'groupAllOf');
+    const groupAll = chainRequiresAll(policies, "groupAllOf");
     if (target.groupAllOf.some((group) => !groupAll.has((0, exports.stableRefKey)(group))))
         return false;
     if (!chainImpliesAny(policies, refSet(target.groupAnyOf), groupAll, (policy) => policy.groupAnyOf.map(exports.stableRefKey)))
         return false;
-    const conditionAll = chainRequiresAll(policies, 'conditionAllOf');
+    const conditionAll = chainRequiresAll(policies, "conditionAllOf");
     if (target.conditionAllOf.some((condition) => !conditionAll.has((0, exports.revisionRefKey)(condition))))
         return false;
     return true;
@@ -217,91 +446,260 @@ const normalizePath = (path, routeSpace) => {
     let normalized = path;
     if (!routeSpace.caseSensitive) {
         normalized = normalized
-            .split('/')
-            .map((segment) => segment.startsWith(':') ? segment : segment.toLowerCase())
-            .join('/');
-    }
-    if (routeSpace.trailingSlash === 'remove' && normalized.length > 1)
-        normalized = normalized.replace(/\/+$/, '');
-    if (routeSpace.trailingSlash === 'require' && normalized.length > 1 && !normalized.endsWith('/'))
-        normalized += '/';
+            .split("/")
+            .map((segment) => segment.startsWith(":") ? segment : segment.toLowerCase())
+            .join("/");
+    }
+    if (routeSpace.trailingSlash === "remove" && normalized.length > 1)
+        normalized = normalized.replace(/\/+$/, "");
+    if (routeSpace.trailingSlash === "require" &&
+        normalized.length > 1 &&
+        !normalized.endsWith("/"))
+        normalized += "/";
     return normalized;
 };
+const acceptedTrailingSlashStates = (claim) => {
+    if (claim.matcher.trailingSlash === "remove")
+        return new Set([false, true]);
+    if (claim.matcher.trailingSlash === "require")
+        return new Set([true]);
+    return new Set([
+        claim.normalizedPath.length > 1 && claim.normalizedPath.endsWith("/"),
+    ]);
+};
+const routeSegmentParameter = (segment) => segment.match(/^[:$]([A-Za-z][A-Za-z0-9_-]*)$/)?.[1];
+const parameterTypeFor = (claim, name) => claim.matcher.parameters.find((parameter) => parameter.name === name)?.type;
+const compiledRouteClaimsOverlap = (leftInput, rightInput) => {
+    const left = declarative_control_1.CompiledRouteClaimSchema.parse(leftInput);
+    const right = declarative_control_1.CompiledRouteClaimSchema.parse(rightInput);
+    if (![...acceptedTrailingSlashStates(left)].some((state) => acceptedTrailingSlashStates(right).has(state)))
+        return false;
+    const leftSegments = left.normalizedPath.split("/").filter(Boolean);
+    const rightSegments = right.normalizedPath.split("/").filter(Boolean);
+    if (leftSegments.length !== rightSegments.length)
+        return false;
+    return leftSegments.every((leftSegment, index) => {
+        const rightSegment = rightSegments[index];
+        const leftParameter = routeSegmentParameter(leftSegment);
+        const rightParameter = routeSegmentParameter(rightSegment);
+        if (!leftParameter && !rightParameter) {
+            if (left.matcher.caseSensitive && right.matcher.caseSensitive)
+                return leftSegment === rightSegment;
+            return leftSegment.toLowerCase() === rightSegment.toLowerCase();
+        }
+        if (leftParameter && !rightParameter) {
+            const type = parameterTypeFor(left, leftParameter);
+            return !!type && routeParameterPattern(type).test(rightSegment);
+        }
+        if (!leftParameter && rightParameter) {
+            const type = parameterTypeFor(right, rightParameter);
+            return !!type && routeParameterPattern(type).test(leftSegment);
+        }
+        const leftType = parameterTypeFor(left, leftParameter);
+        const rightType = parameterTypeFor(right, rightParameter);
+        if (!leftType || !rightType)
+            return false;
+        return (!(leftType === "integer" && rightType === "uuid") &&
+            !(leftType === "uuid" && rightType === "integer"));
+    });
+};
+exports.compiledRouteClaimsOverlap = compiledRouteClaimsOverlap;
 const compileRouteClaims = (input) => {
+    const embeddedTakeovers = input.claims.flatMap((claim) => {
+        const authorization = "legacyRouteTakeoverAuthorization" in claim
+            ? claim.legacyRouteTakeoverAuthorization
+            : undefined;
+        return authorization ? [authorization] : [];
+    });
+    const takeoverAuthorizations = [
+        ...(input.legacyRouteTakeoverAuthorizations ?? []),
+        ...embeddedTakeovers,
+    ].map((authorization, index) => {
+        try {
+            return (0, exports.parseExactLegacyRouteTakeoverAuthorization)(authorization);
+        }
+        catch (error) {
+            if (error instanceof DeclarativeControlCompilationError) {
+                throw new DeclarativeControlCompilationError(error.code, `legacyRouteTakeoverAuthorizations[${index}].${error.path}`, error.message);
+            }
+            throw error;
+        }
+    });
     const registrations = input.routeSpaces.map((entry, index) => {
         const revisionRef = declarative_control_1.RevisionRefSchema.parse(entry.revisionRef);
         const routeSpace = declarative_control_1.RouteSpaceSchema.parse(entry.routeSpace);
-        if (revisionRef.kind !== 'route-space' || revisionRef.id !== routeSpace.routeSpaceId) {
-            throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', `routeSpaces[${index}]`, 'RouteSpace registration identity does not match its pinned revision.');
+        if (revisionRef.kind !== "route-space" ||
+            revisionRef.id !== routeSpace.routeSpaceId) {
+            throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `routeSpaces[${index}]`, "RouteSpace registration identity does not match its pinned revision.");
         }
         return { revisionRef, routeSpace };
     });
-    assertUniqueRegistryKeys(registrations.map((entry) => (0, exports.revisionRefKey)(entry.revisionRef)), 'routeSpaces');
-    const routeSpacesByRevision = new Map(registrations.map((entry) => [(0, exports.revisionRefKey)(entry.revisionRef), entry.routeSpace]));
-    const normalizedPaths = new Set();
+    assertUniqueRegistryKeys(registrations.map((entry) => (0, exports.revisionRefKey)(entry.revisionRef)), "routeSpaces");
+    const routeSpacesByRevision = new Map(registrations.map((entry) => [
+        (0, exports.revisionRefKey)(entry.revisionRef),
+        entry.routeSpace,
+    ]));
     const compiled = [];
     input.claims.forEach((inputClaim, index) => {
-        const parsedClaim = 'surface' in inputClaim
-            ? declarative_control_1.RouteClaimSchema.parse(inputClaim)
-            : declarative_control_1.LegacyRouteClaimSchema.parse(inputClaim);
-        const routeSpace = routeSpacesByRevision.get((0, exports.revisionRefKey)(parsedClaim.routeSpaceRevisionRef));
+        const { legacyRouteTakeoverAuthorization: _authorization, ...runtimeClaim } = inputClaim;
+        const legacyClaim = "surface" in runtimeClaim
+            ? declarative_control_1.RouteClaimSchema.parse(runtimeClaim)
+            : declarative_control_1.LegacyRouteClaimSchema.parse(runtimeClaim);
+        const routeSpace = routeSpacesByRevision.get((0, exports.revisionRefKey)(legacyClaim.routeSpaceRevisionRef));
         if (!routeSpace)
-            throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISSING', `routeClaims[${index}].routeSpaceRevisionRef`, 'No exact RouteSpace registration exists.');
+            throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISSING", `routeClaims[${index}].routeSpaceRevisionRef`, "No exact RouteSpace registration exists.");
         const claim = declarative_control_1.RouteClaimSchema.parse({
-            ...parsedClaim,
-            surface: 'surface' in parsedClaim ? parsedClaim.surface : routeSpace.supportedSurface,
+            ...legacyClaim,
+            surface: "surface" in legacyClaim
+                ? legacyClaim.surface
+                : routeSpace.supportedSurface,
         });
         if (routeSpace.supportedSurface !== claim.surface) {
-            throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', `routeClaims[${index}].surface`, `Route claim surface ${claim.surface} does not match RouteSpace ${routeSpace.routeSpaceId}.`);
+            throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `routeClaims[${index}].surface`, `Route claim surface ${claim.surface} does not match RouteSpace ${routeSpace.routeSpaceId}.`);
         }
         if (claim.surface !== input.surface)
             return;
         const normalizedPath = normalizePath(claim.pathTemplate, routeSpace);
         const knownParameters = new Set(routeSpace.parameters.map((parameter) => parameter.name));
-        const pathParameters = [...normalizedPath.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g)].map((match) => match[1]);
+        const pathParameters = [
+            ...normalizedPath.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g),
+        ].map((match) => match[1]);
         if (new Set(pathParameters).size !== pathParameters.length) {
-            throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', `routeClaims[${index}].pathTemplate`, 'Route parameters must be unique within a path.');
+            throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `routeClaims[${index}].pathTemplate`, "Route parameters must be unique within a path.");
         }
         const unknownParameter = pathParameters.find((parameter) => !knownParameters.has(parameter));
         if (unknownParameter) {
-            throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', `routeClaims[${index}].pathTemplate`, `Route parameter ${unknownParameter} is not declared by ${routeSpace.routeSpaceId}.`);
+            throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `routeClaims[${index}].pathTemplate`, `Route parameter ${unknownParameter} is not declared by ${routeSpace.routeSpaceId}.`);
         }
-        const reserved = routeSpace.reservedPaths.some((candidate) => {
-            const normalizedReserved = normalizePath(candidate, routeSpace);
-            return normalizedPath === normalizedReserved || normalizedPath.startsWith(`${normalizedReserved}/`);
-        });
-        if (reserved)
-            throw new DeclarativeControlCompilationError('ROUTE_RESERVED', `routeClaims[${index}].pathTemplate`, `Route ${normalizedPath} is reserved by ${routeSpace.routeSpaceId}.`);
-        const routeIdentity = `${(0, exports.revisionRefKey)(claim.routeSpaceRevisionRef)}:${normalizedPath}`;
-        if (normalizedPaths.has(routeIdentity))
-            throw new DeclarativeControlCompilationError('ROUTE_CONFLICT', `routeClaims[${index}].pathTemplate`, `Duplicate normalized route ${normalizedPath}.`);
-        normalizedPaths.add(routeIdentity);
-        compiled.push(declarative_control_1.CompiledRouteClaimSchema.parse({
+        const matcher = {
+            surface: claim.surface,
+            caseSensitive: routeSpace.caseSensitive,
+            trailingSlash: routeSpace.trailingSlash,
+            parameters: routeSpace.parameters,
+        };
+        const compiledClaim = declarative_control_1.CompiledRouteClaimSchema.parse({
             ...claim,
             normalizedPath,
-            matcher: {
+            matcher,
+        });
+        const reserved = routeSpace.reservedPaths.some((candidate) => {
+            const normalizedReserved = normalizePath(candidate, routeSpace);
+            const reservedClaim = declarative_control_1.CompiledRouteClaimSchema.parse({
+                kind: "canonical",
+                routeSpaceRevisionRef: claim.routeSpaceRevisionRef,
+                pathTemplate: candidate,
                 surface: claim.surface,
-                caseSensitive: routeSpace.caseSensitive,
-                trailingSlash: routeSpace.trailingSlash,
-                parameters: routeSpace.parameters,
-            },
-        }));
+                normalizedPath: normalizedReserved,
+                matcher,
+            });
+            return ((0, exports.compiledRouteClaimsOverlap)(compiledClaim, reservedClaim) ||
+                normalizedPath.startsWith(`${normalizedReserved.replace(/\/+$/, "")}/`));
+        });
+        if (reserved) {
+            const takeover = takeoverAuthorizations.find((authorization) => compiledClaim.kind === "canonical" &&
+                authorization.normalizedPath === compiledClaim.normalizedPath &&
+                (0, exports.sameRevisionRef)(authorization.routeSpaceRevisionRef, compiledClaim.routeSpaceRevisionRef));
+            if (!takeover) {
+                throw new DeclarativeControlCompilationError("ROUTE_RESERVED", `routeClaims[${index}].pathTemplate`, `Route ${normalizedPath} is reserved by ${routeSpace.routeSpaceId}.`);
+            }
+        }
+        const conflict = compiled.find((candidate) => (0, exports.sameRevisionRef)(candidate.routeSpaceRevisionRef, claim.routeSpaceRevisionRef) && (0, exports.compiledRouteClaimsOverlap)(candidate, compiledClaim));
+        if (conflict)
+            throw new DeclarativeControlCompilationError("ROUTE_CONFLICT", `routeClaims[${index}].pathTemplate`, `Route ${normalizedPath} overlaps another active claim pattern.`);
+        compiled.push(compiledClaim);
     });
-    if (!compiled.some((claim) => claim.kind === 'canonical')) {
-        throw new DeclarativeControlCompilationError('ROUTE_CONFLICT', 'routeClaims', 'At least one canonical route claim is required.');
+    if (!compiled.some((claim) => claim.kind === "canonical")) {
+        throw new DeclarativeControlCompilationError("ROUTE_CONFLICT", "routeClaims", "At least one canonical route claim is required.");
     }
     return Object.freeze(compiled);
 };
 exports.compileRouteClaims = compileRouteClaims;
-const routeParameterPattern = (type) => {
-    if (type === 'integer')
+/**
+ * Matches an application-relative request path using only the policy frozen into
+ * a CompiledRouteClaim. Runtime consumers must not reconstruct RouteSpace policy
+ * from product ids or deployment configuration.
+ */
+const matchCompiledRouteClaim = (claimInput, pathInput) => {
+    const claim = declarative_control_1.CompiledRouteClaimSchema.parse(claimInput);
+    const rawPath = String(pathInput || "").trim();
+    if (!rawPath.startsWith("/") ||
+        rawPath.includes("?") ||
+        rawPath.includes("#") ||
+        rawPath.includes("\\") ||
+        rawPath.includes("://")) {
+        return { matched: false, parameters: {} };
+    }
+    const rawSegments = rawPath.split("/");
+    if (rawSegments.some((segment) => segment === "." || segment === ".."))
+        return { matched: false, parameters: {} };
+    const requestHasTrailingSlash = rawPath.length > 1 && rawPath.endsWith("/");
+    if (claim.matcher.trailingSlash === "require" && !requestHasTrailingSlash)
+        return { matched: false, parameters: {} };
+    if (claim.matcher.trailingSlash === "preserve" &&
+        requestHasTrailingSlash !==
+            (claim.normalizedPath.length > 1 && claim.normalizedPath.endsWith("/"))) {
+        return { matched: false, parameters: {} };
+    }
+    const normalizeTrailing = (value) => {
+        if (claim.matcher.trailingSlash === "remove" && value.length > 1)
+            return value.replace(/\/+$/, "");
+        if (claim.matcher.trailingSlash === "require" &&
+            value.length > 1 &&
+            !value.endsWith("/"))
+            return `${value}/`;
+        return value;
+    };
+    const requestPath = normalizeTrailing(rawPath);
+    const templatePath = normalizeTrailing(claim.normalizedPath);
+    const requestSegments = requestPath.split("/").filter(Boolean);
+    const templateSegments = templatePath.split("/").filter(Boolean);
+    if (requestSegments.length !== templateSegments.length)
+        return { matched: false, parameters: {} };
+    const parameterDefinitions = new Map(claim.matcher.parameters.map((parameter) => [parameter.name, parameter]));
+    const parameters = {};
+    const normalizedSegments = [];
+    for (let index = 0; index < templateSegments.length; index += 1) {
+        const template = templateSegments[index];
+        const rawValue = requestSegments[index];
+        const match = template.match(/^[:$]([A-Za-z][A-Za-z0-9_-]*)$/);
+        if (!match) {
+            if ((claim.matcher.caseSensitive ? template : template.toLowerCase()) !==
+                (claim.matcher.caseSensitive ? rawValue : rawValue.toLowerCase())) {
+                return { matched: false, parameters: {} };
+            }
+            normalizedSegments.push(template);
+            continue;
+        }
+        const definition = parameterDefinitions.get(match[1]);
+        let value;
+        try {
+            value = decodeURIComponent(rawValue);
+        }
+        catch {
+            return { matched: false, parameters: {} };
+        }
+        if (!definition || !routeParameterPattern(definition.type).test(value))
+            return { matched: false, parameters: {} };
+        parameters[definition.name] = value;
+        normalizedSegments.push(rawValue);
+    }
+    const canonicalPath = normalizeTrailing(`/${normalizedSegments.join("/")}` || "/");
+    return {
+        matched: true,
+        normalizedPath: canonicalPath,
+        parameters: Object.freeze(parameters),
+    };
+};
+exports.matchCompiledRouteClaim = matchCompiledRouteClaim;
+function routeParameterPattern(type) {
+    if (type === "integer")
         return /^-?\d+$/;
-    if (type === 'uuid')
+    if (type === "uuid")
         return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    if (type === 'slug')
+    if (type === "slug")
         return /^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$/;
     return /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-};
+}
 /**
  * Materializes the browser URL owned by a RouteSpace from an application-relative
  * compiled route. Declarations and runtime resolution remain application-relative;
@@ -310,26 +708,31 @@ const routeParameterPattern = (type) => {
 const materializeRouteSpacePath = (input) => {
     const routeSpace = declarative_control_1.RouteSpaceSchema.parse(input.routeSpace);
     const applicationPath = declarative_control_1.RoutePathTemplateSchema.parse(input.applicationPath);
-    const basePath = routeSpace.basePath === '/' ? '' : routeSpace.basePath.replace(/\/+$/, '');
-    let browserTemplate = normalizePath(`${basePath}${applicationPath === '/' ? '/' : applicationPath}` || '/', routeSpace);
+    const basePath = routeSpace.basePath === "/" ? "" : routeSpace.basePath.replace(/\/+$/, "");
+    let browserTemplate = normalizePath(`${basePath}${applicationPath === "/" ? "/" : applicationPath}` || "/", routeSpace);
     const parameters = input.parameters || {};
     const declared = new Map(routeSpace.parameters.map((parameter) => [parameter.name, parameter]));
-    const referenced = [...browserTemplate.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g)].map((match) => match[1]);
+    const referenced = [
+        ...browserTemplate.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g),
+    ].map((match) => match[1]);
     for (const name of referenced) {
         const definition = declared.get(name);
         const raw = parameters[name];
-        if (!definition || raw === undefined || raw === null || String(raw).trim() === '') {
-            throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', 'parameters', `Route parameter ${name} is not resolved by ${routeSpace.routeSpaceId}.`);
+        if (!definition ||
+            raw === undefined ||
+            raw === null ||
+            String(raw).trim() === "") {
+            throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", "parameters", `Route parameter ${name} is not resolved by ${routeSpace.routeSpaceId}.`);
         }
         const value = String(raw);
         if (!routeParameterPattern(definition.type).test(value)) {
-            throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', `parameters.${name}`, `Route parameter ${name} does not satisfy ${definition.type}.`);
+            throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `parameters.${name}`, `Route parameter ${name} does not satisfy ${definition.type}.`);
         }
         browserTemplate = browserTemplate.replace(`:${name}`, encodeURIComponent(value));
     }
     const unknown = Object.keys(parameters).find((name) => !declared.has(name));
     if (unknown)
-        throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', `parameters.${unknown}`, `RouteSpace ${routeSpace.routeSpaceId} does not declare ${unknown}.`);
+        throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `parameters.${unknown}`, `RouteSpace ${routeSpace.routeSpaceId} does not declare ${unknown}.`);
     return browserTemplate;
 };
 exports.materializeRouteSpacePath = materializeRouteSpacePath;
@@ -339,7 +742,12 @@ const renderTreeDepth = (tree) => {
     tree.nodes.forEach((node) => {
         let depth = 1;
         let parentId = node.parentNodeId;
+        const ancestors = new Set([node.nodeId]);
         while (parentId) {
+            if (ancestors.has(parentId)) {
+                throw new DeclarativeControlCompilationError("RENDER_TREE_INVALID", "page.renderTree.nodes", `RenderTree contains a parent cycle at ${parentId}.`);
+            }
+            ancestors.add(parentId);
             depth += 1;
             parentId = byId.get(parentId)?.parentNodeId;
         }
@@ -347,56 +755,590 @@ const renderTreeDepth = (tree) => {
     });
     return maximum;
 };
-const compareLegacyEntityRef = (reference, revision) => reference.kind === revision.kind
-    && reference.id === revision.id
-    && String(reference.version) === String(revision.revision)
-    && reference.ownerRepo === revision.ownerRepo;
+const compareLegacyEntityRef = (reference, revision) => reference.kind === revision.kind &&
+    reference.id === revision.id &&
+    String(reference.version) === String(revision.revision) &&
+    reference.ownerRepo === revision.ownerRepo;
 const pageDependencies = (page, compilerRevisionRef) => [
-    ...page.routeClaims.map((claim) => ({ role: 'route-space', revisionRef: claim.routeSpaceRevisionRef })),
-    { role: 'shell', revisionRef: page.shellRevisionRef },
+    ...page.routeClaims.map((claim) => ({
+        role: "route-space",
+        revisionRef: claim.routeSpaceRevisionRef,
+    })),
+    { role: "shell", revisionRef: page.shellRevisionRef },
     ...page.capabilityInstances.flatMap((instance) => [
-        { role: 'capability', revisionRef: instance.capabilityRevisionRef },
-        { role: 'provider', revisionRef: instance.providerRevisionRef },
-        { role: 'schema', revisionRef: instance.propertySchemaRevisionRef },
+        {
+            role: "capability",
+            revisionRef: instance.capabilityRevisionRef,
+        },
+        { role: "provider", revisionRef: instance.providerRevisionRef },
+        ...(instance.eventEffects ?? []).map((effect) => ({
+            role: "schema",
+            revisionRef: effect.sourceIntentSchemaRevisionRef,
+        })),
+        {
+            role: "schema",
+            revisionRef: instance.propertySchemaRevisionRef,
+        },
     ]),
+    ...(page.stateDefinitions ?? []).map((state) => ({
+        role: "schema",
+        revisionRef: state.schemaRevisionRef,
+    })),
+    ...(page.interactionBindings ?? []).map((binding) => ({
+        role: "schema",
+        revisionRef: binding.sourceIntentSchemaRevisionRef,
+    })),
     ...page.ontologyBindings.flatMap((binding) => [
-        { role: 'ontology-definition', revisionRef: binding.ontologyDefinitionRevisionRef },
-        ...(binding.viewRevisionRef ? [{ role: 'view', revisionRef: binding.viewRevisionRef }] : []),
-        ...(binding.projectionRevisionRef ? [{ role: 'projection', revisionRef: binding.projectionRevisionRef }] : []),
-        { role: 'schema', revisionRef: binding.renderModelSchemaRevisionRef },
+        {
+            role: "ontology-definition",
+            revisionRef: binding.ontologyDefinitionRevisionRef,
+        },
+        { role: "view", revisionRef: binding.viewRevisionRef },
+        {
+            role: "view",
+            revisionRef: binding.canonicalDataViewRevisionRef,
+        },
+        {
+            role: "schema",
+            revisionRef: binding.renderModelSchemaRevisionRef,
+        },
+        ...(binding.cursorWindow
+            ? [
+                {
+                    role: "schema",
+                    revisionRef: binding.cursorWindow.pageChangeIntentSchemaRevisionRef,
+                },
+            ]
+            : []),
+    ]),
+    ...(page.queryBindings ?? []).flatMap((binding) => [
+        {
+            role: "query-definition",
+            revisionRef: binding.queryDefinitionRevisionRef,
+        },
+        {
+            role: "schema",
+            revisionRef: binding.renderModelSchemaRevisionRef,
+        },
+        ...(binding.targetProjection
+            ? [
+                {
+                    role: "schema",
+                    revisionRef: binding.targetProjection.schemaRevisionRef,
+                },
+            ]
+            : []),
+        ...(binding.streamTargetProjection
+            ? [
+                {
+                    role: "schema",
+                    revisionRef: binding.streamTargetProjection.schemaRevisionRef,
+                },
+            ]
+            : []),
+        ...(binding.cursorWindow
+            ? [
+                {
+                    role: "schema",
+                    revisionRef: binding.cursorWindow.pageChangeIntentSchemaRevisionRef,
+                },
+            ]
+            : []),
     ]),
     ...page.actionBindings.flatMap((binding) => [
-        { role: 'action', revisionRef: binding.commandRevisionRef },
-        { role: 'schema', revisionRef: binding.sourceIntentSchemaRevisionRef },
-        { role: 'schema', revisionRef: binding.inputSchemaRevisionRef },
-        { role: 'schema', revisionRef: binding.resultSchemaRevisionRef },
-        ...(binding.compensationCommandRevisionRef ? [{ role: 'action', revisionRef: binding.compensationCommandRevisionRef }] : []),
+        { role: "action", revisionRef: binding.commandRevisionRef },
+        {
+            role: "schema",
+            revisionRef: binding.sourceIntentSchemaRevisionRef,
+        },
+        { role: "schema", revisionRef: binding.inputSchemaRevisionRef },
+        { role: "schema", revisionRef: binding.resultSchemaRevisionRef },
+        ...(binding.compensationCommandRevisionRef
+            ? [
+                {
+                    role: "action",
+                    revisionRef: binding.compensationCommandRevisionRef,
+                },
+            ]
+            : []),
     ]),
-    ...page.tokenRevisionRefs.map((revisionRef) => ({ role: 'token', revisionRef })),
-    { role: 'performance-budget', revisionRef: page.performanceBudgetRef },
-    { role: 'observation-policy', revisionRef: page.observationPolicyRevisionRef },
-    { role: 'compiler', revisionRef: compilerRevisionRef },
+    ...page.tokenRevisionRefs.map((revisionRef) => ({
+        role: "token",
+        revisionRef,
+    })),
+    { role: "performance-budget", revisionRef: page.performanceBudgetRef },
+    {
+        role: "observation-policy",
+        revisionRef: page.observationPolicyRevisionRef,
+    },
+    { role: "compiler", revisionRef: compilerRevisionRef },
 ];
-const compilePageRuntimeBundle = (input) => {
+const domainQueryDependencies = (definition) => [
+    ...(definition.ontologyDefinitionRevisionRef
+        ? [
+            {
+                role: "ontology-definition",
+                revisionRef: definition.ontologyDefinitionRevisionRef,
+            },
+        ]
+        : []),
+    ...(definition.viewRevisionRef
+        ? [{ role: "view", revisionRef: definition.viewRevisionRef }]
+        : []),
+    ...(definition.canonicalDataViewRevisionRef
+        ? [
+            {
+                role: "view",
+                revisionRef: definition.canonicalDataViewRevisionRef,
+            },
+        ]
+        : []),
+    { role: "schema", revisionRef: definition.inputSchemaRevisionRef },
+    { role: "schema", revisionRef: definition.resultSchemaRevisionRef },
+];
+const singleByStableIdentity = (registrations, kind, id, path) => {
+    const matches = registrations.filter(({ revisionRef }) => revisionRef.kind === kind && revisionRef.id === id);
+    if (matches.length !== 1) {
+        throw new DeclarativeControlCompilationError("DEPENDENCY_MISSING", path, `Expected exactly one active ${kind} registration for ${id}; found ${matches.length}.`);
+    }
+    return matches[0];
+};
+const usesResultValue = (mapping) => Object.values(mapping).some((source) => source.kind === "result-field" ||
+    (source.kind === "expression" &&
+        source.expression !== undefined &&
+        (0, page_expression_1.collectPageExpressionReads)(source.expression).some((read) => read.root === "result")));
+const simpleEntityRef = (revisionRef) => ({
+    kind: revisionRef.kind,
+    id: revisionRef.id,
+    version: revisionRef.revision,
+    ownerRepo: revisionRef.ownerRepo,
+});
+const defaultRenderSurface = {
+    frameOwner: "host",
+    density: "default",
+};
+const defaultRenderScroll = {
+    owner: "surface",
+    axis: "none",
+    virtualizationBoundary: false,
+};
+const defaultRenderLifecycle = {
+    mountPolicy: "always",
+    queryPolicy: "always",
+    retainOnDeactivate: false,
+    deepLink: false,
+    focusReturn: false,
+};
+const resolvePage = (input) => {
     const page = declarative_control_1.PageSchema.parse(input.page);
+    const defaults = {
+        routeSpace: declarative_control_1.RevisionRefSchema.parse(input.defaults.routeSpace),
+        shell: declarative_control_1.RevisionRefSchema.parse(input.defaults.shell),
+        tokens: input.defaults.tokens.map((reference) => declarative_control_1.RevisionRefSchema.parse(reference)),
+        performanceBudget: declarative_control_1.RevisionRefSchema.parse(input.defaults.performanceBudget),
+        observationPolicy: declarative_control_1.RevisionRefSchema.parse(input.defaults.observationPolicy),
+    };
+    const resourceRegistrations = (input.productResources ?? []).map((registration) => ({
+        revisionRef: declarative_control_1.RevisionRefSchema.parse(registration.resourceRevisionRef),
+        registration: declarative_control_http_1.DeclarativeProductResourceRegistrationSchema.parse(registration),
+    }));
+    const resolveResource = (kind, id, fallback, path) => {
+        const targetId = id ?? fallback.id;
+        if (resourceRegistrations.length === 0) {
+            if (targetId !== fallback.id || fallback.kind !== kind) {
+                throw new DeclarativeControlCompilationError("DEPENDENCY_MISSING", path, `No ${kind} registry was supplied for ${targetId}.`);
+            }
+            return fallback;
+        }
+        return singleByStableIdentity(resourceRegistrations, kind, targetId, path)
+            .revisionRef;
+    };
+    const routeSpaceId = page.routeSpace ?? defaults.routeSpace.id;
+    const routeRegistrations = (input.routeSpaces ?? []).map((registration) => ({
+        revisionRef: declarative_control_1.RevisionRefSchema.parse(registration.revisionRef),
+        routeSpace: registration.routeSpace,
+    }));
+    const routeSpaceRevisionRef = routeRegistrations.length === 0
+        ? (() => {
+            if (routeSpaceId !== defaults.routeSpace.id) {
+                throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISSING", "page.routeSpace", `No RouteSpace registry was supplied for ${routeSpaceId}.`);
+            }
+            return defaults.routeSpace;
+        })()
+        : singleByStableIdentity(routeRegistrations, "route-space", routeSpaceId, "page.routeSpace").revisionRef;
+    const shellRevisionRef = resolveResource("shell", page.shell, defaults.shell, "page.shell");
+    const tokenRevisionRefs = page.tokens?.map((id, index) => resolveResource("design-token", id, defaults.tokens[0], `page.tokens[${index}]`)) ?? [...defaults.tokens];
+    const performanceBudgetRef = resolveResource("performance-budget", page.performanceBudget, defaults.performanceBudget, "page.performanceBudget");
+    const observationPolicyRevisionRef = resolveResource("observation-policy", page.observationPolicy, defaults.observationPolicy, "page.observationPolicy");
+    const capabilityRegistrations = input.capabilityRegistry.map((registration) => ({
+        ...registration,
+        revisionRef: declarative_control_1.RevisionRefSchema.parse(registration.capabilityRevisionRef),
+        providerRevisionRef: declarative_control_1.RevisionRefSchema.parse(registration.providerRevisionRef),
+        propertySchemaRevisionRef: declarative_control_1.RevisionRefSchema.parse(registration.propertySchemaRevisionRef),
+        inputPorts: registration.inputPorts.map((port) => ({
+            ...port,
+            schemaRevisionRef: declarative_control_1.RevisionRefSchema.parse(port.schemaRevisionRef),
+        })),
+        outputPorts: registration.outputPorts.map((port) => ({
+            ...port,
+            schemaRevisionRef: declarative_control_1.RevisionRefSchema.parse(port.schemaRevisionRef),
+        })),
+    }));
+    const queryRegistrations = (input.domainQueryRegistry ?? []).map((registration) => ({
+        revisionRef: declarative_control_1.RevisionRefSchema.parse(registration.definitionRevisionRef),
+        definition: declarative_control_1.DomainQueryDefinitionSchema.parse(registration.definition),
+    }));
+    const commandRegistrations = (input.domainCommandRegistry ?? []).map((registration) => ({
+        revisionRef: declarative_control_1.RevisionRefSchema.parse(registration.definitionRevisionRef),
+        definition: registration.definition,
+    }));
+    const schemaRegistrations = (input.schemaRegistry ?? []).map((registration) => ({
+        revisionRef: declarative_control_1.RevisionRefSchema.parse(registration.definitionRevisionRef),
+        definition: registration.definition,
+    }));
+    const stateSchemaById = new Map(schemaRegistrations.map((registration) => [
+        registration.definition.schemaId,
+        registration.revisionRef,
+    ]));
+    const stateDefinitions = (page.state ?? []).map(({ schema, ...state }, index) => {
+        const schemaRevisionRef = stateSchemaById.get(schema);
+        if (!schemaRevisionRef) {
+            throw new DeclarativeControlCompilationError("SCHEMA_DEFINITION_MISMATCH", `page.state[${index}].schema`, `No active Schema registration exists for ${schema}.`);
+        }
+        return { ...state, schemaRevisionRef };
+    });
+    const stateSchemasByStateId = new Map(stateDefinitions.map((definition) => [
+        definition.stateId,
+        definition.schemaRevisionRef,
+    ]));
+    const renderNodes = [];
+    const capabilityInstances = [];
+    const queryBindings = [];
+    const actionBindings = [];
+    const interactionBindings = [];
+    const visitNode = (node, parentNodeId) => {
+        const registration = singleByStableIdentity(capabilityRegistrations, "capability", node.component, `page.body.${node.id}.component`);
+        const children = node.children ?? [];
+        const defaultActivation = {
+            activationId: node.id,
+            mode: "inline",
+        };
+        renderNodes.push({
+            contract: "RenderNode",
+            nodeId: node.id,
+            kind: node.kind ?? "view",
+            version: 1,
+            ownerRepo: registration.providerRevisionRef.ownerRepo,
+            ...(parentNodeId ? { parentNodeId } : {}),
+            children: children.map((child) => child.id),
+            ...(node.slot ? { slot: node.slot } : {}),
+            pageRef: {
+                kind: "page",
+                id: page.pageId,
+                version: 1,
+                ownerRepo: input.pageOwnerRepo,
+            },
+            capabilityRef: simpleEntityRef(registration.revisionRef),
+            providerRef: simpleEntityRef(registration.providerRevisionRef),
+            surface: node.surface ?? defaultRenderSurface,
+            scroll: node.scroll ?? defaultRenderScroll,
+            activation: node.activation ?? defaultActivation,
+            lifecycle: node.lifecycle ?? defaultRenderLifecycle,
+            layout: node.layout ?? { mode: "contents" },
+            ...(node.style ? { style: node.style } : {}),
+            responsive: node.responsive ?? [],
+            state: node.state ?? "idle",
+            renderModel: node.model ?? {},
+            ...(node.repeat
+                ? { repeat: { ...node.repeat, limit: node.repeat.limit ?? 200 } }
+                : {}),
+        });
+        capabilityInstances.push({
+            instanceId: node.id,
+            nodeId: node.id,
+            capabilityRevisionRef: registration.revisionRef,
+            providerRevisionRef: registration.providerRevisionRef,
+            propertySchemaRevisionRef: registration.propertySchemaRevisionRef,
+            properties: node.props ?? {},
+            ...(node.bindings ? { propertyBindings: node.bindings } : {}),
+            ...(node.eventPayloads
+                ? { eventPayloadBindings: node.eventPayloads }
+                : {}),
+            ...(node.effects
+                ? {
+                    eventEffects: node.effects.map((effect, index) => {
+                        const port = registration.outputPorts.find((candidate) => candidate.name === effect.port);
+                        if (!port) {
+                            throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `page.body.${node.id}.effects[${index}].port`, `No output port ${effect.port} exists on ${node.component}.`);
+                        }
+                        return {
+                            sourcePort: effect.port,
+                            sourceIntentSchemaRevisionRef: port.schemaRevisionRef,
+                            refreshBindingIds: effect.refresh,
+                        };
+                    }),
+                }
+                : {}),
+            ...(node.access ? { accessPolicy: node.access } : {}),
+            ...(node.activeWhen ? { activationWhen: node.activeWhen } : {}),
+            allowedSideEffects: [...registration.allowedSideEffects],
+        });
+        for (const [index, binding] of (node.data ?? []).entries()) {
+            const queryRegistration = singleByStableIdentity(queryRegistrations, "domain-query-definition", binding.query, `page.body.${node.id}.data[${index}].query`);
+            const port = registration.inputPorts.find((candidate) => candidate.name === binding.port);
+            if (!port) {
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `page.body.${node.id}.data[${index}].port`, `No input port ${binding.port} exists on ${node.component}.`);
+            }
+            const { query, port: _port, targetProjection, streamTargetProjection, cursorWindow, resultStateBindings, ...rest } = binding;
+            queryBindings.push({
+                ...rest,
+                queryDefinitionRevisionRef: queryRegistration.revisionRef,
+                target: { capabilityInstanceId: node.id, port: binding.port },
+                renderModelSchemaRevisionRef: queryRegistration.definition.resultSchemaRevisionRef,
+                ...(targetProjection
+                    ? {
+                        targetProjection: {
+                            ...targetProjection,
+                            schemaRevisionRef: port.schemaRevisionRef,
+                        },
+                    }
+                    : {}),
+                ...(streamTargetProjection
+                    ? {
+                        streamTargetProjection: {
+                            ...streamTargetProjection,
+                            schemaRevisionRef: port.schemaRevisionRef,
+                        },
+                    }
+                    : {}),
+                ...(cursorWindow
+                    ? {
+                        cursorWindow: {
+                            ...cursorWindow,
+                            pageChangeIntentSchemaRevisionRef: (() => {
+                                const sourceInstanceId = cursorWindow.sourceCapabilityInstanceId ?? node.id;
+                                const sourceRegistration = capabilityInstances.find((instance) => instance.instanceId === sourceInstanceId);
+                                const sourceCapability = sourceRegistration &&
+                                    capabilityRegistrations.find((candidate) => (0, exports.sameRevisionRef)(candidate.revisionRef, sourceRegistration.capabilityRevisionRef));
+                                const sourcePort = sourceCapability?.outputPorts.find((candidate) => candidate.name === cursorWindow.pageChangePort);
+                                if (!sourcePort) {
+                                    throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `page.body.${node.id}.data[${index}].cursorWindow.pageChangePort`, `No output port ${cursorWindow.pageChangePort} exists on the cursor source component.`);
+                                }
+                                return sourcePort.schemaRevisionRef;
+                            })(),
+                        },
+                    }
+                    : {}),
+                ...(resultStateBindings
+                    ? {
+                        resultStateBindings: resultStateBindings.map((stateBinding, stateIndex) => {
+                            const targetStateSchemaRevisionRef = stateSchemasByStateId.get(stateBinding.targetStateId);
+                            if (!targetStateSchemaRevisionRef) {
+                                throw new DeclarativeControlCompilationError("SCHEMA_DEFINITION_MISMATCH", `page.body.${node.id}.data[${index}].resultStateBindings[${stateIndex}].targetStateId`, `Unknown Page state ${stateBinding.targetStateId}.`);
+                            }
+                            return { ...stateBinding, targetStateSchemaRevisionRef };
+                        }),
+                    }
+                    : {}),
+            });
+        }
+        for (const [index, binding] of (node.actions ?? []).entries()) {
+            const commandRegistration = singleByStableIdentity(commandRegistrations, "domain-command", binding.command, `page.body.${node.id}.actions[${index}].command`);
+            const port = registration.outputPorts.find((candidate) => candidate.name === binding.port);
+            if (!port) {
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `page.body.${node.id}.actions[${index}].port`, `No output port ${binding.port} exists on ${node.component}.`);
+            }
+            const inputSchemaRevisionRef = stateSchemaById.get(commandRegistration.definition.inputSchemaRef);
+            const resultSchemaRevisionRef = commandRegistration.definition
+                .outputSchemaRef
+                ? stateSchemaById.get(commandRegistration.definition.outputSchemaRef)
+                : undefined;
+            if (!inputSchemaRevisionRef || !resultSchemaRevisionRef) {
+                throw new DeclarativeControlCompilationError("COMMAND_DEFINITION_MISMATCH", `page.body.${node.id}.actions[${index}].command`, `Command ${binding.command} must resolve active input and output Schemas.`);
+            }
+            const compensationCommandRevisionRef = binding.compensationCommand
+                ? singleByStableIdentity(commandRegistrations, "domain-command", binding.compensationCommand, `page.body.${node.id}.actions[${index}].compensationCommand`).revisionRef
+                : undefined;
+            const { command, port: _port, compensationCommand, ...rest } = binding;
+            actionBindings.push({
+                ...rest,
+                commandRevisionRef: commandRegistration.revisionRef,
+                source: { capabilityInstanceId: node.id, port: binding.port },
+                sourceIntentSchemaRevisionRef: port.schemaRevisionRef,
+                inputSchemaRevisionRef,
+                ...(compensationCommandRevisionRef
+                    ? { compensationCommandRevisionRef }
+                    : {}),
+                resultSchemaRevisionRef,
+            });
+        }
+        for (const [index, binding] of (node.on ?? []).entries()) {
+            const port = registration.outputPorts.find((candidate) => candidate.name === binding.port);
+            if (!port) {
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `page.body.${node.id}.on[${index}].port`, `No output port ${binding.port} exists on ${node.component}.`);
+            }
+            const matchingAction = actionBindings.find((action) => action.source.capabilityInstanceId === node.id &&
+                action.source.port === binding.port);
+            const { port: _port, ...rest } = binding;
+            interactionBindings.push({
+                ...rest,
+                source: { capabilityInstanceId: node.id, port: binding.port },
+                sourceIntentSchemaRevisionRef: port.schemaRevisionRef,
+                ...(usesResultValue(binding.inputMapping)
+                    ? (() => {
+                        if (!matchingAction) {
+                            throw new DeclarativeControlCompilationError("COMMAND_DEFINITION_MISMATCH", `page.body.${node.id}.on[${index}].inputMapping`, "A result-driven interaction requires an Action on the same output port.");
+                        }
+                        return {
+                            sourceResultSchemaRevisionRef: matchingAction.resultSchemaRevisionRef,
+                        };
+                    })()
+                    : {}),
+            });
+        }
+        children.forEach((child) => visitNode(child, node.id));
+    };
+    visitNode(page.body);
+    const resolved = {
+        contract: "Page",
+        schemaVersion: 1,
+        pageId: page.pageId,
+        tenantScope: page.tenantScope,
+        identity: page.identity,
+        supportedSurfaces: [page.surface],
+        lifecycle: page.lifecycle,
+        ...(page.routeStatePresentations
+            ? { routeStatePresentations: page.routeStatePresentations }
+            : {}),
+        routeClaims: [
+            {
+                kind: "canonical",
+                surface: page.surface,
+                routeSpaceRevisionRef,
+                pathTemplate: page.route,
+            },
+        ],
+        shellRevisionRef,
+        renderTree: {
+            contract: "RenderTree",
+            treeId: page.pageId,
+            product: page.surface,
+            rootNodeId: page.body.id,
+            nodes: renderNodes,
+        },
+        capabilityInstances,
+        ...(stateDefinitions.length ? { stateDefinitions } : {}),
+        ...(page.entryTransitions
+            ? {
+                entryTransitions: page.entryTransitions.map(({ target, ...transition }, index) => {
+                    const matches = (input.targetRegistry ?? []).filter((registration) => registration.stableTargetRef.kind === target.kind &&
+                        registration.stableTargetRef.id === target.id);
+                    if (matches.length !== 1) {
+                        throw new DeclarativeControlCompilationError("PAGE_ENTRY_TARGET_UNRELEASED", `page.entryTransitions[${index}].target`, `Expected one active ${target.kind} target for ${target.id}; found ${matches.length}.`);
+                    }
+                    return { ...transition, targetRef: matches[0].stableTargetRef };
+                }),
+            }
+            : {}),
+        ...(interactionBindings.length ? { interactionBindings } : {}),
+        ontologyBindings: [],
+        ...(queryBindings.length ? { queryBindings } : {}),
+        actionBindings,
+        pageAccessPolicy: page.access,
+        managementAccess: page.managementAccess,
+        tokenRevisionRefs,
+        performanceBudgetRef,
+        observationPolicyRevisionRef,
+        privacyClassification: page.privacyClassification,
+    };
+    return declarative_control_1.ResolvedPageSchema.parse(resolved);
+};
+exports.resolvePage = resolvePage;
+const compilePageRuntimeBundle = (input) => {
+    const parsedPage = declarative_control_1.ResolvedPageSchema.parse(input.page);
+    const page = {
+        ...parsedPage,
+        routeStatePresentations: parsedPage.routeStatePresentations ?? [],
+        stateDefinitions: parsedPage.stateDefinitions ?? [],
+        entryTransitions: parsedPage.entryTransitions ?? [],
+        interactionBindings: parsedPage.interactionBindings ?? [],
+        queryBindings: parsedPage.queryBindings ?? [],
+    };
     const pageRevisionRef = declarative_control_1.RevisionRefSchema.parse(input.pageRevisionRef);
     const release = declarative_control_1.PageReleaseSchema.parse(input.release);
     const releaseRevisionRef = declarative_control_1.RevisionRefSchema.parse(input.releaseRevisionRef);
     const compilerRevisionRef = declarative_control_1.RevisionRefSchema.parse(input.compilerRevisionRef);
     const scope = declarative_control_1.TenantScopeSchema.parse(page.tenantScope);
-    assertSameTenantScope(release.tenantScope, scope, 'release.tenantScope');
-    assertRevisionIdentity(pageRevisionRef, 'page', page.pageId, scope, 'pageRevisionRef');
-    assertRevisionIdentity(release.pageRevisionRef, 'page', page.pageId, scope, 'release.pageRevisionRef');
+    assertSameTenantScope(release.tenantScope, scope, "release.tenantScope");
+    assertRevisionIdentity(pageRevisionRef, "page", page.pageId, scope, "pageRevisionRef");
+    assertRevisionIdentity(release.pageRevisionRef, "page", page.pageId, scope, "release.pageRevisionRef");
     if (!(0, exports.sameRevisionRef)(pageRevisionRef, release.pageRevisionRef))
-        throw new DeclarativeControlCompilationError('REVISION_MISMATCH', 'release.pageRevisionRef', 'Release does not pin the supplied Page revision.');
-    assertRevisionIdentity(releaseRevisionRef, 'page-release', release.releaseSlotId, scope, 'releaseRevisionRef');
+        throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.pageRevisionRef", "Release does not pin the supplied Page revision.");
+    assertRevisionIdentity(releaseRevisionRef, "page-release", release.releaseSlotId, scope, "releaseRevisionRef");
     requireReleaseReady(release);
     requireDependencies(release.dependencySnapshot, pageDependencies(page, compilerRevisionRef));
     assertDependencyScopes(release.dependencySnapshot, scope);
+    const queryRegistrations = (input.domainQueryRegistry ?? []).map((registration, index) => {
+        const definitionRevisionRef = declarative_control_1.RevisionRefSchema.parse(registration.definitionRevisionRef);
+        const definition = declarative_control_1.DomainQueryDefinitionSchema.parse(registration.definition);
+        assertSameTenantScope(definition.tenantScope, scope, `domainQueryRegistry[${index}].definition.tenantScope`);
+        assertRevisionIdentity(definitionRevisionRef, "domain-query-definition", definition.queryId, scope, `domainQueryRegistry[${index}].definitionRevisionRef`);
+        if (definitionRevisionRef.contentHash !== (0, exports.canonicalContentHash)(definition)) {
+            throw new DeclarativeControlCompilationError("QUERY_DEFINITION_MISMATCH", `domainQueryRegistry[${index}].definitionRevisionRef.contentHash`, "Domain Query registry entry does not match its exact definition content hash.");
+        }
+        return { definitionRevisionRef, definition };
+    });
+    assertUniqueRegistryKeys(queryRegistrations.map((registration) => (0, exports.revisionRefKey)(registration.definitionRevisionRef)), "domainQueryRegistry");
+    const queryDefinitionsByRevision = new Map(queryRegistrations.map((registration) => [
+        (0, exports.revisionRefKey)(registration.definitionRevisionRef),
+        registration.definition,
+    ]));
+    page.queryBindings.forEach((binding, index) => {
+        const definition = queryDefinitionsByRevision.get((0, exports.revisionRefKey)(binding.queryDefinitionRevisionRef));
+        if (!definition) {
+            throw new DeclarativeControlCompilationError("QUERY_DEFINITION_MISMATCH", `queryBindings[${index}].queryDefinitionRevisionRef`, "Query binding does not resolve to one exact governed Domain Query definition.");
+        }
+        if (!(0, exports.sameRevisionRef)(definition.resultSchemaRevisionRef, binding.renderModelSchemaRevisionRef)) {
+            throw new DeclarativeControlCompilationError("QUERY_DEFINITION_MISMATCH", `queryBindings[${index}].renderModelSchemaRevisionRef`, "Query binding render model does not match the exact Domain Query result schema.");
+        }
+        if (!(0, exports.accessPolicyChainImplies)([page.pageAccessPolicy], definition.accessPolicy) &&
+            binding.accessFailure !== "render-forbidden") {
+            throw new DeclarativeControlCompilationError("AUDIENCE_WIDER_THAN_TARGET", `queryBindings[${index}]`, "Page access is wider than the governed Domain Query audience.");
+        }
+        const sourceKind = definition.dataSource?.kind ?? "exact-view";
+        if (binding.execution === "local-state" && sourceKind !== "page-state") {
+            throw new DeclarativeControlCompilationError("QUERY_DEFINITION_MISMATCH", `queryBindings[${index}].execution`, "A local-state binding must resolve to one page-state Domain Query definition.");
+        }
+        if (binding.execution === "server" && sourceKind === "page-state") {
+            throw new DeclarativeControlCompilationError("QUERY_DEFINITION_MISMATCH", `queryBindings[${index}].execution`, "A page-state Domain Query cannot execute on the Server.");
+        }
+        requireDependencies(release.dependencySnapshot, domainQueryDependencies(definition));
+    });
+    const shellRegistration = declarative_control_http_1.DeclarativeProductResourceRegistrationSchema.parse(input.shellRegistration);
+    if (shellRegistration.resourceKind !== "shell" ||
+        !(0, exports.sameRevisionRef)(shellRegistration.resourceRevisionRef, page.shellRevisionRef) ||
+        (0, exports.declarativeProductResourceRevisionHash)(shellRegistration) !==
+            shellRegistration.resourceRevisionRef.contentHash ||
+        (0, exports.declarativeProductResourceSourceHash)(shellRegistration.document) !==
+            shellRegistration.sourceContentHash) {
+        throw new DeclarativeControlCompilationError("SHELL_REVISION_MISMATCH", "shellRegistration", "The active Shell registration does not match the Page exact Shell revision.");
+    }
+    if (!shellRegistration.supportedSurfaces.includes(release.target.surface)) {
+        throw new DeclarativeControlCompilationError("SHELL_SURFACE_MISMATCH", "shellRegistration.supportedSurfaces", "The active Shell registration does not support the release surface.");
+    }
+    const shellDocument = declarative_control_http_1.DeclarativeShellResourceDocumentSchema.parse(shellRegistration.document);
+    const shellChrome = shellDocument.surfaceChrome.find((entry) => entry.surface === release.target.surface);
+    if (!shellChrome) {
+        throw new DeclarativeControlCompilationError("SHELL_CHROME_UNAVAILABLE", "shellRegistration.document.surfaceChrome", "The active Shell does not declare chrome for the release surface.");
+    }
+    const shellDescriptor = {
+        shellRevisionRef: page.shellRevisionRef,
+        header: shellChrome.header,
+    };
     if (page.renderTree.nodes.length > input.limits.maxRenderNodes)
-        throw new DeclarativeControlCompilationError('RENDER_NODE_LIMIT_EXCEEDED', 'page.renderTree.nodes', 'RenderTree exceeds the caller-approved node limit.');
+        throw new DeclarativeControlCompilationError("RENDER_NODE_LIMIT_EXCEEDED", "page.renderTree.nodes", "RenderTree exceeds the caller-approved node limit.");
     if (renderTreeDepth(page.renderTree) > input.limits.maxRenderDepth)
-        throw new DeclarativeControlCompilationError('RENDER_DEPTH_EXCEEDED', 'page.renderTree.nodes', 'RenderTree exceeds the caller-approved depth limit.');
+        throw new DeclarativeControlCompilationError("RENDER_DEPTH_EXCEEDED", "page.renderTree.nodes", "RenderTree exceeds the caller-approved depth limit.");
     const renderTree = (0, render_tree_compiler_1.compileRenderTree)(page.renderTree).tree;
     const instancesByNode = new Map(page.capabilityInstances.map((instance) => [instance.nodeId, instance]));
     const registrations = input.capabilityRegistry.map((registration, registrationIndex) => ({
@@ -405,65 +1347,234 @@ const compilePageRuntimeBundle = (input) => {
         providerRevisionRef: declarative_control_1.RevisionRefSchema.parse(registration.providerRevisionRef),
         inputPorts: registration.inputPorts.map((port, portIndex) => {
             const schemaRevisionRef = declarative_control_1.RevisionRefSchema.parse(port.schemaRevisionRef);
-            if (schemaRevisionRef.kind !== 'schema') {
-                throw new DeclarativeControlCompilationError('PORT_TYPE_MISMATCH', `capabilityRegistry[${registrationIndex}].inputPorts[${portIndex}].schemaRevisionRef`, 'Capability ports must pin schema revisions.');
+            if (schemaRevisionRef.kind !== "schema") {
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `capabilityRegistry[${registrationIndex}].inputPorts[${portIndex}].schemaRevisionRef`, "Capability ports must pin schema revisions.");
             }
             return { ...port, schemaRevisionRef };
         }),
         outputPorts: registration.outputPorts.map((port, portIndex) => {
             const schemaRevisionRef = declarative_control_1.RevisionRefSchema.parse(port.schemaRevisionRef);
-            if (schemaRevisionRef.kind !== 'schema') {
-                throw new DeclarativeControlCompilationError('PORT_TYPE_MISMATCH', `capabilityRegistry[${registrationIndex}].outputPorts[${portIndex}].schemaRevisionRef`, 'Capability ports must pin schema revisions.');
+            if (schemaRevisionRef.kind !== "schema") {
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `capabilityRegistry[${registrationIndex}].outputPorts[${portIndex}].schemaRevisionRef`, "Capability ports must pin schema revisions.");
             }
             return { ...port, schemaRevisionRef };
         }),
     }));
-    assertUniqueRegistryKeys(registrations.map((registration) => `${(0, exports.revisionRefKey)(registration.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(registration.providerRevisionRef)}`), 'capabilityRegistry');
+    assertUniqueRegistryKeys(registrations.map((registration) => `${(0, exports.revisionRefKey)(registration.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(registration.providerRevisionRef)}`), "capabilityRegistry");
     const registrationsByPair = new Map(registrations.map((registration) => [
         `${(0, exports.revisionRefKey)(registration.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(registration.providerRevisionRef)}`,
         registration,
     ]));
     page.capabilityInstances.forEach((instance, index) => {
         const node = renderTree.nodes.find((candidate) => candidate.nodeId === instance.nodeId);
-        if (!node || !compareLegacyEntityRef(node.capabilityRef, instance.capabilityRevisionRef)
-            || !node.providerRef || !compareLegacyEntityRef(node.providerRef, instance.providerRevisionRef)
-            || node.pageRef.id !== page.pageId) {
-            throw new DeclarativeControlCompilationError('CAPABILITY_BINDING_MISMATCH', `capabilityInstances[${index}]`, 'RenderTree node identity does not match the declared capability/provider instance.');
+        if (!node ||
+            !compareLegacyEntityRef(node.capabilityRef, instance.capabilityRevisionRef) ||
+            !node.providerRef ||
+            !compareLegacyEntityRef(node.providerRef, instance.providerRevisionRef) ||
+            node.pageRef.id !== page.pageId) {
+            throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", `capabilityInstances[${index}]`, "RenderTree node identity does not match the declared capability/provider instance.");
         }
         const registration = registrationsByPair.get(`${(0, exports.revisionRefKey)(instance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(instance.providerRevisionRef)}`);
-        if (!registration?.editorEligible) {
-            throw new DeclarativeControlCompilationError('CAPABILITY_NOT_EDITOR_ELIGIBLE', `capabilityInstances[${index}]`, 'Capability/provider pair is not editor-eligible.');
+        if (!registration) {
+            throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", `capabilityInstances[${index}]`, "Capability/provider pair has no exact governed Design registration.");
         }
         if (instance.allowedSideEffects.some((sideEffect) => !registration.allowedSideEffects.includes(sideEffect))) {
-            throw new DeclarativeControlCompilationError('CAPABILITY_BINDING_MISMATCH', `capabilityInstances[${index}].allowedSideEffects`, 'Page requests undeclared provider side effects.');
+            throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", `capabilityInstances[${index}].allowedSideEffects`, "Page requests undeclared provider side effects.");
+        }
+        if (!(0, exports.sameRevisionRef)(instance.propertySchemaRevisionRef, registration.propertySchemaRevisionRef)) {
+            throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", `capabilityInstances[${index}].propertySchemaRevisionRef`, "Capability properties do not pin the exact schema registered by the active Design catalog.");
+        }
+        if (!(0, exports.accessPolicyChainImplies)([
+            page.pageAccessPolicy,
+            ...(instance.accessPolicy ? [instance.accessPolicy] : []),
+        ], registration.accessPolicy)) {
+            throw new DeclarativeControlCompilationError("AUDIENCE_WIDER_THAN_TARGET", `capabilityInstances[${index}]`, "Page access is wider than the governed capability audience.");
+        }
+    });
+    if (instancesByNode.size !== page.capabilityInstances.length) {
+        throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", "capabilityInstances", "Each executable RenderTree node must be governed by at most one capability instance.");
+    }
+    renderTree.nodes.forEach((node, index) => {
+        if (!node.providerRef)
+            return;
+        if (!instancesByNode.has(node.nodeId)) {
+            throw new DeclarativeControlCompilationError("CAPABILITY_BINDING_MISMATCH", `renderTree.nodes[${index}]`, "Every provider-backed RenderTree node must be governed by one capability instance.");
         }
     });
     page.ontologyBindings.forEach((binding, index) => {
         const instance = page.capabilityInstances.find((candidate) => candidate.instanceId === binding.target.capabilityInstanceId);
-        const registration = instance && registrationsByPair.get(`${(0, exports.revisionRefKey)(instance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(instance.providerRevisionRef)}`);
+        const registration = instance &&
+            registrationsByPair.get(`${(0, exports.revisionRefKey)(instance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(instance.providerRevisionRef)}`);
+        const port = registration?.inputPorts.find((candidate) => candidate.name === binding.target.port);
+        if (!port ||
+            !(0, exports.sameRevisionRef)(port.schemaRevisionRef, binding.renderModelSchemaRevisionRef)) {
+            throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `ontologyBindings[${index}].target.port`, "Ontology render model does not match the registered capability input port.");
+        }
+        if (binding.cursorWindow) {
+            const sourceInstance = page.capabilityInstances.find((candidate) => candidate.instanceId ===
+                (binding.cursorWindow.sourceCapabilityInstanceId ??
+                    binding.target.capabilityInstanceId));
+            const sourceRegistration = sourceInstance &&
+                registrationsByPair.get(`${(0, exports.revisionRefKey)(sourceInstance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(sourceInstance.providerRevisionRef)}`);
+            const pageChangePort = sourceRegistration?.outputPorts.find((candidate) => candidate.name === binding.cursorWindow.pageChangePort);
+            if (!pageChangePort ||
+                !(0, exports.sameRevisionRef)(pageChangePort.schemaRevisionRef, binding.cursorWindow.pageChangeIntentSchemaRevisionRef)) {
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `ontologyBindings[${index}].cursorWindow.pageChangePort`, "Cursor-window page-change intent does not match the registered capability output port.");
+            }
+        }
+    });
+    page.queryBindings.forEach((binding, index) => {
+        const instance = page.capabilityInstances.find((candidate) => candidate.instanceId === binding.target.capabilityInstanceId);
+        const registration = instance &&
+            registrationsByPair.get(`${(0, exports.revisionRefKey)(instance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(instance.providerRevisionRef)}`);
         const port = registration?.inputPorts.find((candidate) => candidate.name === binding.target.port);
-        if (!port || !(0, exports.sameRevisionRef)(port.schemaRevisionRef, binding.renderModelSchemaRevisionRef)) {
-            throw new DeclarativeControlCompilationError('PORT_TYPE_MISMATCH', `ontologyBindings[${index}].target.port`, 'Ontology render model does not match the registered capability input port.');
+        if (!port ||
+            !(0, exports.sameRevisionRef)(port.schemaRevisionRef, binding.targetProjection?.schemaRevisionRef ??
+                binding.renderModelSchemaRevisionRef)) {
+            throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `queryBindings[${index}].target.port`, "Domain Query render model does not match the registered capability input port.");
+        }
+        if (binding.streamTargetProjection &&
+            (!port ||
+                !(0, exports.sameRevisionRef)(port.schemaRevisionRef, binding.streamTargetProjection.schemaRevisionRef))) {
+            throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `queryBindings[${index}].streamTargetProjection`, "Stream render model does not match the registered capability input port.");
+        }
+        if (binding.cursorWindow) {
+            const sourceInstance = page.capabilityInstances.find((candidate) => candidate.instanceId ===
+                (binding.cursorWindow.sourceCapabilityInstanceId ??
+                    binding.target.capabilityInstanceId));
+            const sourceRegistration = sourceInstance &&
+                registrationsByPair.get(`${(0, exports.revisionRefKey)(sourceInstance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(sourceInstance.providerRevisionRef)}`);
+            const pageChangePort = sourceRegistration?.outputPorts.find((candidate) => candidate.name === binding.cursorWindow.pageChangePort);
+            if (!pageChangePort ||
+                !(0, exports.sameRevisionRef)(pageChangePort.schemaRevisionRef, binding.cursorWindow.pageChangeIntentSchemaRevisionRef)) {
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `queryBindings[${index}].cursorWindow.pageChangePort`, "Cursor-window page-change intent does not match the registered capability output port.");
+            }
+        }
+    });
+    page.capabilityInstances.forEach((instance, index) => {
+        const registration = registrationsByPair.get(`${(0, exports.revisionRefKey)(instance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(instance.providerRevisionRef)}`);
+        instance.eventPayloadBindings?.forEach((binding, bindingIndex) => {
+            if (!registration?.outputPorts.some((port) => port.name === binding.port))
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `capabilityInstances[${index}].eventPayloadBindings[${bindingIndex}]`, "Event payload projection must reference a registered output port.");
+        });
+        instance.eventEffects?.forEach((effect, effectIndex) => {
+            const port = registration?.outputPorts.find((candidate) => candidate.name === effect.sourcePort);
+            if (!port ||
+                !(0, exports.sameRevisionRef)(port.schemaRevisionRef, effect.sourceIntentSchemaRevisionRef))
+                throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `capabilityInstances[${index}].eventEffects[${effectIndex}]`, "Event effect source must match an exact registered output port schema.");
+        });
+    });
+    page.interactionBindings.forEach((binding, index) => {
+        const instance = page.capabilityInstances.find((candidate) => candidate.instanceId === binding.source.capabilityInstanceId);
+        const registration = instance &&
+            registrationsByPair.get(`${(0, exports.revisionRefKey)(instance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(instance.providerRevisionRef)}`);
+        const port = registration?.outputPorts.find((candidate) => candidate.name === binding.source.port);
+        if (!port ||
+            !(0, exports.sameRevisionRef)(port.schemaRevisionRef, binding.sourceIntentSchemaRevisionRef)) {
+            throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `interactionBindings[${index}].sourceIntentSchemaRevisionRef`, "Interaction source intent does not match the registered capability output port.");
         }
     });
     page.actionBindings.forEach((binding, index) => {
         const instance = page.capabilityInstances.find((candidate) => candidate.instanceId === binding.source.capabilityInstanceId);
-        const registration = instance && registrationsByPair.get(`${(0, exports.revisionRefKey)(instance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(instance.providerRevisionRef)}`);
+        const registration = instance &&
+            registrationsByPair.get(`${(0, exports.revisionRefKey)(instance.capabilityRevisionRef)}:${(0, exports.revisionRefKey)(instance.providerRevisionRef)}`);
         const port = registration?.outputPorts.find((candidate) => candidate.name === binding.source.port);
-        if (!port || !(0, exports.sameRevisionRef)(port.schemaRevisionRef, binding.sourceIntentSchemaRevisionRef)) {
-            throw new DeclarativeControlCompilationError('PORT_TYPE_MISMATCH', `actionBindings[${index}].sourceIntentSchemaRevisionRef`, 'Action source intent does not match the registered capability output port.');
+        if (!port ||
+            !(0, exports.sameRevisionRef)(port.schemaRevisionRef, binding.sourceIntentSchemaRevisionRef)) {
+            throw new DeclarativeControlCompilationError("PORT_TYPE_MISMATCH", `actionBindings[${index}].sourceIntentSchemaRevisionRef`, "Action source intent does not match the registered capability output port.");
         }
     });
-    const routeClaims = (0, exports.compileRouteClaims)({ claims: page.routeClaims, routeSpaces: input.routeSpaces, surface: release.target.surface });
-    const releaseRoute = routeClaims.find((claim) => claim.kind === 'canonical' && claim.normalizedPath === release.target.normalizedPath);
-    if (!releaseRoute || !(0, exports.sameRevisionRef)(releaseRoute.routeSpaceRevisionRef, release.target.routeSpaceRevisionRef)) {
-        throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', 'release.target', 'Release target does not match a canonical Page route claim.');
+    const routeClaims = (0, exports.compileRouteClaims)({
+        claims: page.routeClaims,
+        routeSpaces: input.routeSpaces,
+        surface: release.target.surface,
+        legacyRouteTakeoverAuthorizations: release.target
+            .legacyRouteTakeoverAuthorization
+            ? [release.target.legacyRouteTakeoverAuthorization]
+            : [],
+    });
+    const releaseRoute = routeClaims.find((claim) => claim.kind === "canonical" &&
+        claim.normalizedPath === release.target.normalizedPath);
+    if (!releaseRoute ||
+        !(0, exports.sameRevisionRef)(releaseRoute.routeSpaceRevisionRef, release.target.routeSpaceRevisionRef)) {
+        throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", "release.target", "Release target does not match an exact Page route claim.");
     }
     if (!page.supportedSurfaces.includes(release.target.surface)) {
-        throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', 'release.target.surface', 'Page does not support the release surface.');
+        throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", "release.target.surface", "Page does not support the release surface.");
     }
+    const routeTargets = (input.targetRegistry ?? []).map((registration, index) => ({
+        ...registration,
+        stableTargetRef: declarative_control_1.StableRefSchema.parse(registration.stableTargetRef),
+        targetRevisionRef: declarative_control_1.RevisionRefSchema.parse(registration.targetRevisionRef),
+        ...(registration.releaseRevisionRef
+            ? {
+                releaseRevisionRef: declarative_control_1.RevisionRefSchema.parse(registration.releaseRevisionRef),
+            }
+            : {}),
+        accessPolicy: declarative_control_1.AccessPolicySchema.parse(registration.accessPolicy),
+        routeClaim: declarative_control_1.CompiledRouteClaimSchema.parse(registration.routeClaim),
+        sourceIndex: index,
+    }));
+    assertUniqueRegistryKeys(routeTargets.map((registration) => (0, exports.stableRefKey)(registration.stableTargetRef)), "targetRegistry");
+    const entryTransitions = page.entryTransitions.map((transition, index) => {
+        const matches = routeTargets.filter((registration) => registration.kind === "route" &&
+            (0, exports.sameStableRef)(registration.stableTargetRef, transition.targetRef) &&
+            registration.surface === release.target.surface);
+        if (matches.length !== 1) {
+            throw new DeclarativeControlCompilationError("PAGE_ENTRY_TARGET_UNRELEASED", `entryTransitions[${index}].targetRef`, "Entry transition target must resolve to one exact active route registration on the same surface.");
+        }
+        const target = matches[0];
+        if (target.releaseRevisionRef &&
+            !["page-release", "workbench-release"].includes(target.releaseRevisionRef.kind)) {
+            throw new DeclarativeControlCompilationError("PAGE_ENTRY_TARGET_UNRELEASED", `entryTransitions[${index}].targetRef`, "Entry transition Release provenance must identify a Page or Workbench Release.");
+        }
+        if (target.routeClaim.kind !== "canonical") {
+            throw new DeclarativeControlCompilationError("PAGE_ENTRY_TARGET_UNRELEASED", `entryTransitions[${index}].targetRef`, "Entry transition targets must expose one canonical route claim.");
+        }
+        if (!(0, exports.sameStableRef)(target.stableTargetRef, target.targetRevisionRef)) {
+            throw new DeclarativeControlCompilationError("PAGE_ENTRY_TARGET_UNRELEASED", `targetRegistry[${target.sourceIndex}]`, "Entry transition target registration identity is not exact.");
+        }
+        // Entry transitions may narrow into a separately protected route. The target
+        // route remains authoritative and re-evaluates its own access policy after
+        // navigation, so a source Page must not inherit the target's permissions.
+        const requiredPathParameters = [
+            ...target.routeClaim.normalizedPath.matchAll(/:([A-Za-z][A-Za-z0-9_-]*)/g),
+        ].map((match) => match[1]);
+        const mappedPathParameters = Object.keys(transition.pathParameters);
+        const missing = requiredPathParameters.find((name) => !mappedPathParameters.includes(name));
+        const unknown = mappedPathParameters.find((name) => !requiredPathParameters.includes(name));
+        if (missing || unknown) {
+            throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `entryTransitions[${index}].pathParameters`, missing
+                ? `Entry transition does not resolve target route parameter ${missing}.`
+                : `Entry transition maps unknown target route parameter ${unknown}.`);
+        }
+        requireDependencies(release.dependencySnapshot, [
+            {
+                role: target.targetRevisionRef.kind,
+                revisionRef: target.targetRevisionRef,
+            },
+            ...(target.releaseRevisionRef
+                ? [
+                    {
+                        role: target.releaseRevisionRef.kind,
+                        revisionRef: target.releaseRevisionRef,
+                    },
+                ]
+                : []),
+        ]);
+        return {
+            ...transition,
+            browsingContext: transition.browsingContext ?? "same",
+            targetRevisionRef: target.targetRevisionRef,
+            ...(target.releaseRevisionRef
+                ? { targetReleaseRevisionRef: target.releaseRevisionRef }
+                : {}),
+            targetAccessPolicy: target.accessPolicy,
+            targetRouteClaim: target.routeClaim,
+        };
+    });
     const unsigned = {
-        contract: 'PageRuntimeBundle',
+        contract: "PageRuntimeBundle",
         schemaVersion: 1,
         tenantScope: scope,
         releaseRevisionRef,
@@ -476,10 +1587,17 @@ const compilePageRuntimeBundle = (input) => {
         pageRevisionRef,
         surface: release.target.surface,
         routeClaims,
+        routeStatePresentations: page.routeStatePresentations.filter((presentation) => presentation.surface === release.target.surface),
         shellRevisionRef: page.shellRevisionRef,
+        shellDescriptor,
         renderTree,
         capabilityInstances: page.capabilityInstances,
+        deniedCapabilityInstanceIds: [],
+        stateDefinitions: page.stateDefinitions,
+        entryTransitions,
+        interactionBindings: page.interactionBindings,
         ontologyBindings: page.ontologyBindings,
+        queryBindings: page.queryBindings,
         actionBindings: page.actionBindings,
         pageAccessPolicy: page.pageAccessPolicy,
         tokenRevisionRefs: page.tokenRevisionRefs,
@@ -487,33 +1605,60 @@ const compilePageRuntimeBundle = (input) => {
         observationPolicyRevisionRef: page.observationPolicyRevisionRef,
         privacyClassification: page.privacyClassification,
     };
-    return deepFreeze(declarative_control_1.PageRuntimeBundleSchema.parse({ ...unsigned, contentHash: (0, exports.canonicalContentHash)(unsigned) }));
+    return deepFreeze(declarative_control_1.PageRuntimeBundleSchema.parse({
+        ...unsigned,
+        contentHash: (0, exports.canonicalContentHash)(unsigned),
+    }));
 };
 exports.compilePageRuntimeBundle = compilePageRuntimeBundle;
 const workbenchDependencyRole = (kind) => {
     switch (kind) {
-        case 'workflow': return 'workflow';
-        case 'agent': return 'agent';
-        case 'capability': return 'capability';
-        case 'design': return 'design';
-        case 'built-in-application': return 'built-in-application';
-        default: return 'workflow';
+        case "workflow":
+            return "workflow";
+        case "agent":
+            return "agent";
+        case "capability":
+            return "capability";
+        case "design":
+            return "design";
+        case "built-in-application":
+            return "built-in-application";
+        default:
+            return "workflow";
     }
 };
 const workbenchDependencies = (workbench, compilerRevisionRef) => [
-    ...workbench.routeClaims.map((claim) => ({ role: 'route-space', revisionRef: claim.routeSpaceRevisionRef })),
+    ...workbench.routeClaims.map((claim) => ({
+        role: "route-space",
+        revisionRef: claim.routeSpaceRevisionRef,
+    })),
     ...workbench.appInstances.flatMap((instance) => [
-        { role: workbenchDependencyRole(instance.targetRevisionRef.kind), revisionRef: instance.targetRevisionRef },
-        { role: 'provider', revisionRef: instance.providerRevisionRef },
-        { role: 'schema', revisionRef: instance.inputSchemaRevisionRef },
+        {
+            role: workbenchDependencyRole(instance.targetRevisionRef.kind),
+            revisionRef: instance.targetRevisionRef,
+        },
+        { role: "provider", revisionRef: instance.providerRevisionRef },
+        { role: "schema", revisionRef: instance.inputSchemaRevisionRef },
     ]),
-    { role: 'capability', revisionRef: workbench.layout.hostCapabilityRevisionRef },
-    { role: 'provider', revisionRef: workbench.layout.hostProviderRevisionRef },
-    { role: 'layout-policy', revisionRef: workbench.layout.layoutPolicyRevisionRef },
-    ...workbench.layout.tokenRevisionRefs.map((revisionRef) => ({ role: 'token', revisionRef })),
-    { role: 'performance-budget', revisionRef: workbench.performanceBudgetRef },
-    { role: 'observation-policy', revisionRef: workbench.observationPolicyRevisionRef },
-    { role: 'compiler', revisionRef: compilerRevisionRef },
+    {
+        role: "capability",
+        revisionRef: workbench.layout.hostCapabilityRevisionRef,
+    },
+    { role: "provider", revisionRef: workbench.layout.hostProviderRevisionRef },
+    {
+        role: "layout-policy",
+        revisionRef: workbench.layout.layoutPolicyRevisionRef,
+    },
+    ...workbench.layout.tokenRevisionRefs.map((revisionRef) => ({
+        role: "token",
+        revisionRef,
+    })),
+    { role: "performance-budget", revisionRef: workbench.performanceBudgetRef },
+    {
+        role: "observation-policy",
+        revisionRef: workbench.observationPolicyRevisionRef,
+    },
+    { role: "compiler", revisionRef: compilerRevisionRef },
 ];
 const compileWorkbenchRuntimeBundle = (input) => {
     const workbench = declarative_control_1.WorkbenchSchema.parse(input.workbench);
@@ -522,34 +1667,48 @@ const compileWorkbenchRuntimeBundle = (input) => {
     const releaseRevisionRef = declarative_control_1.RevisionRefSchema.parse(input.releaseRevisionRef);
     const compilerRevisionRef = declarative_control_1.RevisionRefSchema.parse(input.compilerRevisionRef);
     const scope = declarative_control_1.TenantScopeSchema.parse(workbench.tenantScope);
-    assertSameTenantScope(release.tenantScope, scope, 'release.tenantScope');
-    if (workbench.purpose === 'template')
-        throw new DeclarativeControlCompilationError('WORKBENCH_TEMPLATE_UNRELEASABLE', 'workbench.purpose', 'Workbench templates cannot be activated.');
-    if (workbench.groups.length > input.limits.maxWorkbenchGroups || workbench.appInstances.length > input.limits.maxWorkbenchInstances) {
-        throw new DeclarativeControlCompilationError('WORKBENCH_INSTANCE_LIMIT_EXCEEDED', 'workbench', 'Workbench exceeds caller-approved compilation limits.');
-    }
-    assertRevisionIdentity(workbenchRevisionRef, 'workbench', workbench.workbenchId, scope, 'workbenchRevisionRef');
-    assertRevisionIdentity(release.workbenchRevisionRef, 'workbench', workbench.workbenchId, scope, 'release.workbenchRevisionRef');
+    assertSameTenantScope(release.tenantScope, scope, "release.tenantScope");
+    if (workbench.purpose === "template")
+        throw new DeclarativeControlCompilationError("WORKBENCH_TEMPLATE_UNRELEASABLE", "workbench.purpose", "Workbench templates cannot be activated.");
+    if (workbench.groups.length > input.limits.maxWorkbenchGroups ||
+        workbench.appInstances.length > input.limits.maxWorkbenchInstances) {
+        throw new DeclarativeControlCompilationError("WORKBENCH_INSTANCE_LIMIT_EXCEEDED", "workbench", "Workbench exceeds caller-approved compilation limits.");
+    }
+    assertRevisionIdentity(workbenchRevisionRef, "workbench", workbench.workbenchId, scope, "workbenchRevisionRef");
+    assertRevisionIdentity(release.workbenchRevisionRef, "workbench", workbench.workbenchId, scope, "release.workbenchRevisionRef");
     if (!(0, exports.sameRevisionRef)(workbenchRevisionRef, release.workbenchRevisionRef))
-        throw new DeclarativeControlCompilationError('REVISION_MISMATCH', 'release.workbenchRevisionRef', 'Release does not pin the supplied Workbench revision.');
-    assertRevisionIdentity(releaseRevisionRef, 'workbench-release', release.releaseSlotId, scope, 'releaseRevisionRef');
+        throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.workbenchRevisionRef", "Release does not pin the supplied Workbench revision.");
+    assertRevisionIdentity(releaseRevisionRef, "workbench-release", release.releaseSlotId, scope, "releaseRevisionRef");
     if (release.target.workbenchId !== workbench.workbenchId)
-        throw new DeclarativeControlCompilationError('REVISION_MISMATCH', 'release.target.workbenchId', 'Release target does not match Workbench identity.');
+        throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.target.workbenchId", "Release target does not match Workbench identity.");
     requireReleaseReady(release);
     requireDependencies(release.dependencySnapshot, workbenchDependencies(workbench, compilerRevisionRef));
     assertDependencyScopes(release.dependencySnapshot, scope);
-    const routeClaims = (0, exports.compileRouteClaims)({ claims: workbench.routeClaims, routeSpaces: input.routeSpaces, surface: release.target.surface });
-    const releaseRoute = routeClaims.find((claim) => claim.kind === 'canonical' && claim.normalizedPath === release.target.normalizedPath);
-    if (!releaseRoute || !(0, exports.sameRevisionRef)(releaseRoute.routeSpaceRevisionRef, release.target.routeSpaceRevisionRef)) {
-        throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', 'release.target', 'Release target does not match a canonical Workbench route claim.');
+    const routeClaims = (0, exports.compileRouteClaims)({
+        claims: workbench.routeClaims,
+        routeSpaces: input.routeSpaces,
+        surface: release.target.surface,
+        legacyRouteTakeoverAuthorizations: release.target
+            .legacyRouteTakeoverAuthorization
+            ? [release.target.legacyRouteTakeoverAuthorization]
+            : [],
+    });
+    const releaseRoute = routeClaims.find((claim) => claim.kind === "canonical" &&
+        claim.normalizedPath === release.target.normalizedPath);
+    if (!releaseRoute ||
+        !(0, exports.sameRevisionRef)(releaseRoute.routeSpaceRevisionRef, release.target.routeSpaceRevisionRef)) {
+        throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", "release.target", "Release target does not match an exact Workbench route claim.");
     }
     const targetRegistry = input.targetRegistry.map((registration) => ({
         stableTargetRef: declarative_control_1.StableRefSchema.parse(registration.stableTargetRef),
         targetRevisionRef: declarative_control_1.RevisionRefSchema.parse(registration.targetRevisionRef),
         accessPolicy: declarative_control_1.AccessPolicySchema.parse(registration.accessPolicy),
     }));
-    assertUniqueRegistryKeys(targetRegistry.map((registration) => (0, exports.stableRefKey)(registration.stableTargetRef)), 'targetRegistry');
-    const targetsByStableRef = new Map(targetRegistry.map((registration) => [(0, exports.stableRefKey)(registration.stableTargetRef), registration]));
+    assertUniqueRegistryKeys(targetRegistry.map((registration) => (0, exports.stableRefKey)(registration.stableTargetRef)), "targetRegistry");
+    const targetsByStableRef = new Map(targetRegistry.map((registration) => [
+        (0, exports.stableRefKey)(registration.stableTargetRef),
+        registration,
+    ]));
     const groupsById = new Map(workbench.groups.map((group) => [group.groupId, group]));
     const appInstances = workbench.appInstances.map((instance, index) => {
         const stableTarget = declarative_control_1.StableRefSchema.parse({
@@ -557,23 +1716,30 @@ const compileWorkbenchRuntimeBundle = (input) => {
             id: instance.targetRevisionRef.id,
             ownerRepo: instance.targetRevisionRef.ownerRepo,
             visibility: instance.targetRevisionRef.visibility,
-            ...(instance.targetRevisionRef.tenantScope ? { tenantScope: instance.targetRevisionRef.tenantScope } : {}),
+            ...(instance.targetRevisionRef.tenantScope
+                ? { tenantScope: instance.targetRevisionRef.tenantScope }
+                : {}),
         });
         const registration = targetsByStableRef.get((0, exports.stableRefKey)(stableTarget));
-        if (!registration || !(0, exports.sameStableRef)(registration.stableTargetRef, stableFromRevision(registration.targetRevisionRef))
-            || !(0, exports.sameRevisionRef)(registration.targetRevisionRef, instance.targetRevisionRef)) {
-            throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', `appInstances[${index}].targetRevisionRef`, 'Workbench app target is not present at the exact registered revision.');
+        if (!registration ||
+            !(0, exports.sameStableRef)(registration.stableTargetRef, stableFromRevision(registration.targetRevisionRef)) ||
+            !(0, exports.sameRevisionRef)(registration.targetRevisionRef, instance.targetRevisionRef)) {
+            throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `appInstances[${index}].targetRevisionRef`, "Workbench app target is not present at the exact registered revision.");
         }
         assertTenantCompatible(instance.targetRevisionRef, scope, `appInstances[${index}].targetRevisionRef`);
         const group = groupsById.get(instance.groupId);
-        const chain = [workbench.workbenchAccessPolicy, ...(group?.accessPolicy ? [group.accessPolicy] : []), instance.accessPolicy];
+        const chain = [
+            workbench.workbenchAccessPolicy,
+            ...(group?.accessPolicy ? [group.accessPolicy] : []),
+            instance.accessPolicy,
+        ];
         if (!(0, exports.accessPolicyChainImplies)(chain, registration.accessPolicy)) {
-            throw new DeclarativeControlCompilationError('AUDIENCE_WIDER_THAN_TARGET', `appInstances[${index}].accessPolicy`, 'Workbench and instance audience is wider than the target audience.');
+            throw new DeclarativeControlCompilationError("AUDIENCE_WIDER_THAN_TARGET", `appInstances[${index}].accessPolicy`, "Workbench and instance audience is wider than the target audience.");
         }
         return { ...instance, targetAccessPolicy: registration.accessPolicy };
     });
     const unsigned = {
-        contract: 'WorkbenchRuntimeBundle',
+        contract: "WorkbenchRuntimeBundle",
         schemaVersion: 1,
         tenantScope: scope,
         releaseRevisionRef,
@@ -584,6 +1750,12 @@ const compileWorkbenchRuntimeBundle = (input) => {
         diagnostics: [],
         workbenchId: workbench.workbenchId,
         workbenchRevisionRef,
+        identity: {
+            name: workbench.identity.name,
+            ...(workbench.identity.description
+                ? { description: workbench.identity.description }
+                : {}),
+        },
         surface: release.target.surface,
         routeClaims,
         groups: workbench.groups,
@@ -597,7 +1769,10 @@ const compileWorkbenchRuntimeBundle = (input) => {
         observationPolicyRevisionRef: workbench.observationPolicyRevisionRef,
         privacyClassification: workbench.privacyClassification,
     };
-    return deepFreeze(declarative_control_1.WorkbenchRuntimeBundleSchema.parse({ ...unsigned, contentHash: (0, exports.canonicalContentHash)(unsigned) }));
+    return deepFreeze(declarative_control_1.WorkbenchRuntimeBundleSchema.parse({
+        ...unsigned,
+        contentHash: (0, exports.canonicalContentHash)(unsigned),
+    }));
 };
 exports.compileWorkbenchRuntimeBundle = compileWorkbenchRuntimeBundle;
 const navigationDepth = (navigation) => {
@@ -617,7 +1792,7 @@ const navigationDepth = (navigation) => {
 const orderedNavigationNodes = (navigation) => {
     const children = new Map();
     navigation.nodes.forEach((node) => {
-        const parent = node.parentNodeId ?? '';
+        const parent = node.parentNodeId ?? "";
         const siblings = children.get(parent) ?? [];
         children.set(parent, [...siblings, node]);
     });
@@ -629,17 +1804,32 @@ const orderedNavigationNodes = (navigation) => {
             append(node.nodeId);
         }
     };
-    append('');
+    append("");
     return ordered;
 };
 const navigationDependencies = (navigation, release, compilerRevisionRef) => [
     ...release.resolvedTargets.flatMap((target) => [
-        { role: target.targetRevisionRef.kind === 'domain-command' ? 'action' : target.targetRevisionRef.kind, revisionRef: target.targetRevisionRef },
-        ...(target.releaseRevisionRef ? [{ role: target.releaseRevisionRef.kind, revisionRef: target.releaseRevisionRef }] : []),
+        {
+            role: target.targetRevisionRef.kind === "domain-command"
+                ? "action"
+                : target.targetRevisionRef.kind,
+            revisionRef: target.targetRevisionRef,
+        },
+        ...(target.releaseRevisionRef
+            ? [
+                {
+                    role: target.releaseRevisionRef.kind,
+                    revisionRef: target.releaseRevisionRef,
+                },
+            ]
+            : []),
     ]),
-    { role: 'performance-budget', revisionRef: navigation.performanceBudgetRef },
-    { role: 'observation-policy', revisionRef: navigation.observationPolicyRevisionRef },
-    { role: 'compiler', revisionRef: compilerRevisionRef },
+    { role: "performance-budget", revisionRef: navigation.performanceBudgetRef },
+    {
+        role: "observation-policy",
+        revisionRef: navigation.observationPolicyRevisionRef,
+    },
+    { role: "compiler", revisionRef: compilerRevisionRef },
 ];
 const compileNavigationRuntimeBundle = (input) => {
     const navigation = declarative_control_1.NavigationSchema.parse(input.navigation);
@@ -648,19 +1838,20 @@ const compileNavigationRuntimeBundle = (input) => {
     const releaseRevisionRef = declarative_control_1.RevisionRefSchema.parse(input.releaseRevisionRef);
     const compilerRevisionRef = declarative_control_1.RevisionRefSchema.parse(input.compilerRevisionRef);
     const scope = declarative_control_1.TenantScopeSchema.parse(navigation.tenantScope);
-    assertSameTenantScope(release.tenantScope, scope, 'release.tenantScope');
+    assertSameTenantScope(release.tenantScope, scope, "release.tenantScope");
     if (navigation.nodes.length > input.limits.maxNavigationNodes)
-        throw new DeclarativeControlCompilationError('NAV_NODE_LIMIT_EXCEEDED', 'navigation.nodes', 'Navigation exceeds the caller-approved node limit.');
+        throw new DeclarativeControlCompilationError("NAV_NODE_LIMIT_EXCEEDED", "navigation.nodes", "Navigation exceeds the caller-approved node limit.");
     if (navigationDepth(navigation) > input.limits.maxNavigationDepth)
-        throw new DeclarativeControlCompilationError('NAV_DEPTH_EXCEEDED', 'navigation.nodes', 'Navigation exceeds the caller-approved depth limit.');
-    assertRevisionIdentity(navigationRevisionRef, 'navigation', navigation.navigationId, scope, 'navigationRevisionRef');
-    assertRevisionIdentity(release.navigationRevisionRef, 'navigation', navigation.navigationId, scope, 'release.navigationRevisionRef');
+        throw new DeclarativeControlCompilationError("NAV_DEPTH_EXCEEDED", "navigation.nodes", "Navigation exceeds the caller-approved depth limit.");
+    assertRevisionIdentity(navigationRevisionRef, "navigation", navigation.navigationId, scope, "navigationRevisionRef");
+    assertRevisionIdentity(release.navigationRevisionRef, "navigation", navigation.navigationId, scope, "release.navigationRevisionRef");
     if (!(0, exports.sameRevisionRef)(navigationRevisionRef, release.navigationRevisionRef))
-        throw new DeclarativeControlCompilationError('REVISION_MISMATCH', 'release.navigationRevisionRef', 'Release does not pin the supplied Navigation revision.');
-    assertRevisionIdentity(releaseRevisionRef, 'navigation-release', release.releaseSlotId, scope, 'releaseRevisionRef');
-    if (release.target.surface !== navigation.supportedSurfaces.find((surface) => surface === release.target.surface)
-        || !navigation.placements.includes(release.target.placement)) {
-        throw new DeclarativeControlCompilationError('REVISION_MISMATCH', 'release.target', 'Navigation release target is not declared by the Navigation record.');
+        throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.navigationRevisionRef", "Release does not pin the supplied Navigation revision.");
+    assertRevisionIdentity(releaseRevisionRef, "navigation-release", release.releaseSlotId, scope, "releaseRevisionRef");
+    if (release.target.surface !==
+        navigation.supportedSurfaces.find((surface) => surface === release.target.surface) ||
+        !navigation.placements.includes(release.target.placement)) {
+        throw new DeclarativeControlCompilationError("REVISION_MISMATCH", "release.target", "Navigation release target is not declared by the Navigation record.");
     }
     requireReleaseReady(release);
     requireDependencies(release.dependencySnapshot, navigationDependencies(navigation, release, compilerRevisionRef));
@@ -672,49 +1863,70 @@ const compileNavigationRuntimeBundle = (input) => {
             surface: declarative_control_1.ProductSurfaceSchema.parse(registration.surface),
             accessPolicy: declarative_control_1.AccessPolicySchema.parse(registration.accessPolicy),
         };
-        if (registration.kind === 'route') {
+        if (registration.kind === "route") {
             const routeClaim = declarative_control_1.CompiledRouteClaimSchema.parse(registration.routeClaim);
             if (routeClaim.surface !== common.surface) {
-                throw new DeclarativeControlCompilationError('ROUTE_SPACE_MISMATCH', `targetRegistry[${index}].routeClaim.surface`, 'Navigation route claim must match its registered surface.');
+                throw new DeclarativeControlCompilationError("ROUTE_SPACE_MISMATCH", `targetRegistry[${index}].routeClaim.surface`, "Navigation route claim must match its registered surface.");
             }
             return {
                 ...common,
-                kind: 'route',
-                releaseRevisionRef: registration.releaseRevisionRef ? declarative_control_1.RevisionRefSchema.parse(registration.releaseRevisionRef) : undefined,
+                kind: "route",
+                releaseRevisionRef: registration.releaseRevisionRef
+                    ? declarative_control_1.RevisionRefSchema.parse(registration.releaseRevisionRef)
+                    : undefined,
                 routeClaim,
             };
         }
-        if (registration.kind === 'registered-menu-action') {
+        if (registration.kind === "registered-menu-action") {
             const sourceCatalogRevisionRef = declarative_control_1.RevisionRefSchema.parse(registration.sourceCatalogRevisionRef);
-            if (sourceCatalogRevisionRef.kind !== 'application-menu-catalog' || registration.targetRevisionRef.kind !== 'menu-action') {
-                throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', 'targetRegistry', 'Registered Menu Actions require exact menu-action and application-menu-catalog revisions.');
+            if (sourceCatalogRevisionRef.kind !== "application-menu-catalog" ||
+                registration.targetRevisionRef.kind !== "menu-action") {
+                throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "targetRegistry", "Registered Menu Actions require exact menu-action and application-menu-catalog revisions.");
             }
             if (registration.inputSchemaRef && !registration.validateInput) {
-                throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', 'targetRegistry', 'Registered Menu Actions with input schemas require the active catalog validator.');
+                throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "targetRegistry", "Registered Menu Actions with input schemas require the active catalog validator.");
             }
-            return { ...common, kind: 'registered-menu-action', applicationId: registration.applicationId, actionRef: registration.actionRef, inputSchemaRef: registration.inputSchemaRef, validateInput: registration.validateInput, sourceCatalogRevisionRef };
+            return {
+                ...common,
+                kind: "registered-menu-action",
+                applicationId: registration.applicationId,
+                actionRef: registration.actionRef,
+                inputSchemaRef: registration.inputSchemaRef,
+                validateInput: registration.validateInput,
+                sourceCatalogRevisionRef,
+            };
         }
-        if (registration.targetRevisionRef.kind !== 'domain-command') {
-            throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', 'targetRegistry', 'Governed DomainCommand actions require an exact domain-command revision.');
+        if (registration.targetRevisionRef.kind !== "domain-command") {
+            throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "targetRegistry", "Governed DomainCommand actions require an exact domain-command revision.");
         }
         const inputSchemaRevisionRef = declarative_control_1.RevisionRefSchema.parse(registration.inputSchemaRevisionRef);
         const resultSchemaRevisionRef = registration.resultSchemaRevisionRef
             ? declarative_control_1.RevisionRefSchema.parse(registration.resultSchemaRevisionRef)
             : undefined;
-        if (inputSchemaRevisionRef.kind !== 'schema' || (resultSchemaRevisionRef && resultSchemaRevisionRef.kind !== 'schema')) {
-            throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', 'targetRegistry', 'Governed DomainCommand actions require exact input and output Schema revisions.');
+        if (inputSchemaRevisionRef.kind !== "schema" ||
+            (resultSchemaRevisionRef && resultSchemaRevisionRef.kind !== "schema")) {
+            throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "targetRegistry", "Governed DomainCommand actions require exact input and output Schema revisions.");
         }
-        return { ...common, kind: 'governed-domain-command', inputSchemaRevisionRef, resultSchemaRevisionRef };
+        return {
+            ...common,
+            kind: "governed-domain-command",
+            inputSchemaRevisionRef,
+            resultSchemaRevisionRef,
+        };
     });
-    assertUniqueRegistryKeys(targetRegistry.map((registration) => (0, exports.stableRefKey)(registration.stableTargetRef)), 'targetRegistry');
-    const targetsByStableRef = new Map(targetRegistry.map((registration) => [(0, exports.stableRefKey)(registration.stableTargetRef), registration]));
+    assertUniqueRegistryKeys(targetRegistry.map((registration) => (0, exports.stableRefKey)(registration.stableTargetRef)), "targetRegistry");
+    const targetsByStableRef = new Map(targetRegistry.map((registration) => [
+        (0, exports.stableRefKey)(registration.stableTargetRef),
+        registration,
+    ]));
     const releasedByNodeId = new Map(release.resolvedTargets.map((target) => [target.nodeId, target]));
     const unavailableByNodeId = new Map((release.unavailableTargets ?? []).map((target) => [target.nodeId, target]));
     const nodesById = new Map(navigation.nodes.map((node) => [node.nodeId, node]));
     for (const target of release.unavailableTargets ?? []) {
         const node = nodesById.get(target.nodeId);
-        if (node?.kind !== 'target' || !(0, exports.sameStableRef)(node.targetRef, target.stableTargetRef)) {
-            throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', 'release.unavailableTargets', 'An unavailable target must identify its source Page node exactly.');
+        if (node?.kind !== "target" ||
+            !(0, exports.sameStableRef)(node.targetRef, target.stableTargetRef)) {
+            throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", "release.unavailableTargets", "An unavailable target must identify its source Page node exactly.");
         }
     }
     const nodes = orderedNavigationNodes(navigation).map((node, index) => {
@@ -722,22 +1934,26 @@ const compileNavigationRuntimeBundle = (input) => {
         let parentId = node.parentNodeId;
         while (parentId) {
             const parent = nodesById.get(parentId);
-            if (parent?.kind === 'group')
+            if (parent?.kind === "group")
                 ancestors.unshift(parent.audience);
             parentId = parent?.parentNodeId ?? null;
         }
-        if (node.kind !== 'target')
+        if (node.kind !== "target")
             return { ...node, ancestorAccessPolicies: ancestors };
-        if (!['page', 'workbench', 'menu-action', 'domain-command'].includes(node.targetRef.kind)) {
-            throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', `nodes[${index}].targetRef.kind`, 'Navigation targets may reference only Page, Workbench, registered Menu Action, or DomainCommand identities.');
+        if (!["page", "workbench", "menu-action", "domain-command"].includes(node.targetRef.kind)) {
+            throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].targetRef.kind`, "Navigation targets may reference only Page, Workbench, registered Menu Action, or DomainCommand identities.");
         }
         const registration = targetsByStableRef.get((0, exports.stableRefKey)(node.targetRef));
         const released = releasedByNodeId.get(node.nodeId);
         const unavailable = unavailableByNodeId.get(node.nodeId);
-        if (!registration && unavailable && node.targetRef.kind === 'page' && (0, exports.sameStableRef)(unavailable.stableTargetRef, node.targetRef)) {
+        if (!registration &&
+            unavailable &&
+            node.targetRef.kind === "page" &&
+            (0, exports.sameStableRef)(unavailable.stableTargetRef, node.targetRef)) {
             assertTenantCompatible(node.targetRef, scope, `nodes[${index}].targetRef`);
-            if (unavailable.accessPolicy && !(0, exports.accessPolicyChainImplies)([...ancestors, node.audience], unavailable.accessPolicy)) {
-                throw new DeclarativeControlCompilationError('AUDIENCE_WIDER_THAN_TARGET', `nodes[${index}].audience`, 'Effective Navigation audience is wider than the last verified target audience.');
+            if (unavailable.accessPolicy &&
+                !(0, exports.accessPolicyChainImplies)([...ancestors, node.audience], unavailable.accessPolicy)) {
+                throw new DeclarativeControlCompilationError("AUDIENCE_WIDER_THAN_TARGET", `nodes[${index}].audience`, "Effective Navigation audience is wider than the last verified target audience.");
             }
             return {
                 ...node,
@@ -745,80 +1961,100 @@ const compileNavigationRuntimeBundle = (input) => {
                 parameterMapping: {},
                 ancestorAccessPolicies: ancestors,
                 resolvedTarget: {
-                    kind: 'unavailable',
+                    kind: "unavailable",
                     nodeId: node.nodeId,
                     stableTargetRef: node.targetRef,
                     accessPolicy: unavailable.accessPolicy,
                 },
             };
         }
-        if (!registration || !released
-            || !(0, exports.sameStableRef)(registration.stableTargetRef, stableFromRevision(registration.targetRevisionRef))
-            || !(0, exports.sameStableRef)(registration.stableTargetRef, released.stableTargetRef)
-            || !(0, exports.sameRevisionRef)(registration.targetRevisionRef, released.targetRevisionRef)
-            || (registration.kind === 'route' && (Boolean(registration.releaseRevisionRef) !== Boolean(released.releaseRevisionRef)
-                || (registration.releaseRevisionRef && released.releaseRevisionRef && !(0, exports.sameRevisionRef)(registration.releaseRevisionRef, released.releaseRevisionRef))))) {
-            throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', `nodes[${index}].targetRef`, 'Navigation target is not resolved to the exact active release recorded by NavigationRelease.');
+        if (!registration ||
+            !released ||
+            !(0, exports.sameStableRef)(registration.stableTargetRef, stableFromRevision(registration.targetRevisionRef)) ||
+            !(0, exports.sameStableRef)(registration.stableTargetRef, released.stableTargetRef) ||
+            !(0, exports.sameRevisionRef)(registration.targetRevisionRef, released.targetRevisionRef) ||
+            (registration.kind === "route" &&
+                (Boolean(registration.releaseRevisionRef) !==
+                    Boolean(released.releaseRevisionRef) ||
+                    (registration.releaseRevisionRef &&
+                        released.releaseRevisionRef &&
+                        !(0, exports.sameRevisionRef)(registration.releaseRevisionRef, released.releaseRevisionRef))))) {
+            throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].targetRef`, "Navigation target is not resolved to the exact active release recorded by NavigationRelease.");
         }
         if (registration.surface !== release.target.surface) {
-            throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', `nodes[${index}].targetRef`, 'Navigation target is active on another surface.');
+            throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].targetRef`, "Navigation target is active on another surface.");
         }
         assertTenantCompatible(registration.targetRevisionRef, scope, `nodes[${index}].targetRef`);
         if (!(0, exports.accessPolicyChainImplies)([...ancestors, node.audience], registration.accessPolicy)) {
-            throw new DeclarativeControlCompilationError('AUDIENCE_WIDER_THAN_TARGET', `nodes[${index}].audience`, 'Effective Navigation audience is wider than the target audience.');
+            throw new DeclarativeControlCompilationError("AUDIENCE_WIDER_THAN_TARGET", `nodes[${index}].audience`, "Effective Navigation audience is wider than the target audience.");
         }
         const mappedInput = Object.fromEntries(Object.entries(node.parameterMapping).map(([name, source]) => {
-            if (source.kind !== 'constant') {
-                throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', `nodes[${index}].parameterMapping.${name}`, 'Navigation actions accept only publication-time constant input.');
+            if (source.kind !== "constant") {
+                throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].parameterMapping.${name}`, "Navigation actions accept only publication-time constant input.");
             }
             return [name, source.value];
         }));
         let resolvedTarget;
-        if (registration.kind === 'route') {
-            resolvedTarget = { ...released, kind: 'route', accessPolicy: registration.accessPolicy, routeClaim: registration.routeClaim };
+        if (registration.kind === "route") {
+            resolvedTarget = {
+                ...released,
+                kind: "route",
+                accessPolicy: registration.accessPolicy,
+                routeClaim: registration.routeClaim,
+            };
         }
-        else if (registration.kind === 'registered-menu-action') {
+        else if (registration.kind === "registered-menu-action") {
             if (!registration.inputSchemaRef && Object.keys(mappedInput).length > 0) {
-                throw new DeclarativeControlCompilationError('NAV_TARGET_UNRELEASED', `nodes[${index}].parameterMapping`, 'The registered Menu Action does not accept input.');
+                throw new DeclarativeControlCompilationError("NAV_TARGET_UNRELEASED", `nodes[${index}].parameterMapping`, "The registered Menu Action does not accept input.");
             }
             let input;
             try {
-                input = common_1.JsonObjectSchema.parse(registration.validateInput ? registration.validateInput(mappedInput) : mappedInput);
+                input = common_1.JsonObjectSchema.parse(registration.validateInput
+                    ? registration.validateInput(mappedInput)
+                    : mappedInput);
             }
             catch (error) {
-                throw new DeclarativeControlCompilationError('NAV_ACTION_INPUT_INVALID', `nodes[${index}].parameterMapping`, `Registered Menu Action input failed its active catalog schema: ${error instanceof Error ? error.message : String(error)}`);
+                throw new DeclarativeControlCompilationError("NAV_ACTION_INPUT_INVALID", `nodes[${index}].parameterMapping`, `Registered Menu Action input failed its active catalog schema: ${error instanceof Error ? error.message : String(error)}`);
             }
-            const sourceDependency = release.dependencySnapshot.find((dependency) => dependency.role === 'application-menu-catalog' && (0, exports.sameRevisionRef)(dependency.revisionRef, registration.sourceCatalogRevisionRef));
+            const sourceDependency = release.dependencySnapshot.find((dependency) => dependency.role === "application-menu-catalog" &&
+                (0, exports.sameRevisionRef)(dependency.revisionRef, registration.sourceCatalogRevisionRef));
             if (!sourceDependency)
-                throw new DeclarativeControlCompilationError('DEPENDENCY_MISSING', `nodes[${index}].targetRef`, 'Registered Menu Action source catalog is not pinned by NavigationRelease.');
+                throw new DeclarativeControlCompilationError("DEPENDENCY_MISSING", `nodes[${index}].targetRef`, "Registered Menu Action source catalog is not pinned by NavigationRelease.");
             resolvedTarget = {
                 ...released,
-                kind: 'registered-menu-action',
+                kind: "registered-menu-action",
                 accessPolicy: registration.accessPolicy,
-                execution: 'client',
+                execution: "client",
                 applicationId: registration.applicationId,
                 actionRef: registration.actionRef,
-                ...(registration.inputSchemaRef ? { inputSchemaRef: registration.inputSchemaRef } : {}),
+                ...(registration.inputSchemaRef
+                    ? { inputSchemaRef: registration.inputSchemaRef }
+                    : {}),
                 input,
                 sourceCatalogRevisionRef: registration.sourceCatalogRevisionRef,
             };
         }
         else {
-            const inputDependency = release.dependencySnapshot.find((dependency) => dependency.role === 'schema' && (0, exports.sameRevisionRef)(dependency.revisionRef, registration.inputSchemaRevisionRef));
+            const inputDependency = release.dependencySnapshot.find((dependency) => dependency.role === "schema" &&
+                (0, exports.sameRevisionRef)(dependency.revisionRef, registration.inputSchemaRevisionRef));
             const resultDependency = registration.resultSchemaRevisionRef
-                ? release.dependencySnapshot.find((dependency) => dependency.role === 'schema' && (0, exports.sameRevisionRef)(dependency.revisionRef, registration.resultSchemaRevisionRef))
+                ? release.dependencySnapshot.find((dependency) => dependency.role === "schema" &&
+                    (0, exports.sameRevisionRef)(dependency.revisionRef, registration.resultSchemaRevisionRef))
                 : undefined;
-            if (!inputDependency || (registration.resultSchemaRevisionRef && !resultDependency)) {
-                throw new DeclarativeControlCompilationError('DEPENDENCY_MISSING', `nodes[${index}].targetRef`, 'Governed DomainCommand schemas are not pinned by NavigationRelease.');
+            if (!inputDependency ||
+                (registration.resultSchemaRevisionRef && !resultDependency)) {
+                throw new DeclarativeControlCompilationError("DEPENDENCY_MISSING", `nodes[${index}].targetRef`, "Governed DomainCommand schemas are not pinned by NavigationRelease.");
             }
             resolvedTarget = {
                 ...released,
-                kind: 'governed-domain-command',
+                kind: "governed-domain-command",
                 accessPolicy: registration.accessPolicy,
-                execution: 'server',
+                execution: "server",
                 commandRevisionRef: registration.targetRevisionRef,
                 inputSchemaRevisionRef: registration.inputSchemaRevisionRef,
-                ...(registration.resultSchemaRevisionRef ? { resultSchemaRevisionRef: registration.resultSchemaRevisionRef } : {}),
+                ...(registration.resultSchemaRevisionRef
+                    ? { resultSchemaRevisionRef: registration.resultSchemaRevisionRef }
+                    : {}),
                 input: common_1.JsonObjectSchema.parse(mappedInput),
             };
         }
@@ -829,7 +2065,7 @@ const compileNavigationRuntimeBundle = (input) => {
         };
     });
     const unsigned = {
-        contract: 'NavigationRuntimeBundle',
+        contract: "NavigationRuntimeBundle",
         schemaVersion: 1,
         tenantScope: scope,
         releaseRevisionRef,
@@ -846,56 +2082,65 @@ const compileNavigationRuntimeBundle = (input) => {
         performanceBudgetRef: navigation.performanceBudgetRef,
         observationPolicyRevisionRef: navigation.observationPolicyRevisionRef,
     };
-    return deepFreeze(declarative_control_1.NavigationRuntimeBundleSchema.parse({ ...unsigned, contentHash: (0, exports.canonicalContentHash)(unsigned) }));
+    return deepFreeze(declarative_control_1.NavigationRuntimeBundleSchema.parse({
+        ...unsigned,
+        contentHash: (0, exports.canonicalContentHash)(unsigned),
+    }));
 };
 exports.compileNavigationRuntimeBundle = compileNavigationRuntimeBundle;
 const validateWorkbenchRuntimeSet = (bundleInputs) => {
     const bundles = bundleInputs.map((bundle) => declarative_control_1.WorkbenchRuntimeBundleSchema.parse(bundle));
     if (bundles.length === 0) {
-        throw new DeclarativeControlCompilationError('WORKBENCH_RELEASE_SET_INVALID', 'bundles', 'An active Workbench release set must retain at least one Workbench.');
+        throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", "bundles", "An active Workbench release set must retain at least one Workbench.");
     }
     const first = bundles[0];
     const seenIds = new Set();
     const seenOrders = new Set();
     let defaultCount = 0;
     bundles.forEach((bundle, index) => {
-        if (scopeKey(bundle.tenantScope) !== scopeKey(first.tenantScope)
-            || bundle.surface !== first.surface
-            || !(0, exports.sameStableRef)(bundle.target.environmentRef, first.target.environmentRef)) {
-            throw new DeclarativeControlCompilationError('WORKBENCH_RELEASE_SET_INVALID', `bundles[${index}]`, 'Workbench release set entries must share tenant, environment, and surface.');
+        if (scopeKey(bundle.tenantScope) !== scopeKey(first.tenantScope) ||
+            bundle.surface !== first.surface ||
+            !(0, exports.sameStableRef)(bundle.target.environmentRef, first.target.environmentRef)) {
+            throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", `bundles[${index}]`, "Workbench release set entries must share tenant, environment, and surface.");
         }
         if (seenIds.has(bundle.workbenchId))
-            throw new DeclarativeControlCompilationError('WORKBENCH_RELEASE_SET_INVALID', `bundles[${index}].workbenchId`, 'Workbench identities must be unique in an active release set.');
+            throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", `bundles[${index}].workbenchId`, "Workbench identities must be unique in an active release set.");
         if (seenOrders.has(bundle.target.order))
-            throw new DeclarativeControlCompilationError('WORKBENCH_RELEASE_SET_INVALID', `bundles[${index}].target.order`, 'Workbench order values must be unique in an active release set.');
+            throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", `bundles[${index}].target.order`, "Workbench order values must be unique in an active release set.");
         seenIds.add(bundle.workbenchId);
         seenOrders.add(bundle.target.order);
         if (bundle.target.isDefaultCandidate)
             defaultCount += 1;
     });
     if (defaultCount > 1)
-        throw new DeclarativeControlCompilationError('WORKBENCH_RELEASE_SET_INVALID', 'bundles', 'An active Workbench release set may have at most one default candidate.');
-    return Object.freeze([...bundles].sort((left, right) => left.target.order - right.target.order || left.workbenchId.localeCompare(right.workbenchId)));
+        throw new DeclarativeControlCompilationError("WORKBENCH_RELEASE_SET_INVALID", "bundles", "An active Workbench release set may have at most one default candidate.");
+    return Object.freeze([...bundles].sort((left, right) => left.target.order - right.target.order ||
+        left.workbenchId.localeCompare(right.workbenchId)));
 };
 exports.validateWorkbenchRuntimeSet = validateWorkbenchRuntimeSet;
 const resolveWorkbenchEntry = (input) => {
     if (input.requestedWorkbenchId) {
         const requested = input.bundles.find((bundle) => bundle.workbenchId === input.requestedWorkbenchId);
         if (!requested)
-            return { status: 'not-found', workbenchId: input.requestedWorkbenchId };
+            return { status: "not-found", workbenchId: input.requestedWorkbenchId };
         if (!input.isAllowed(requested))
-            return { status: 'forbidden', workbenchId: input.requestedWorkbenchId };
-        return { status: 'resolved', bundle: requested, source: 'explicit' };
+            return { status: "forbidden", workbenchId: input.requestedWorkbenchId };
+        return { status: "resolved", bundle: requested, source: "explicit" };
     }
     const allowed = input.bundles
         .filter(input.isAllowed)
-        .sort((left, right) => left.target.order - right.target.order || left.workbenchId.localeCompare(right.workbenchId));
+        .sort((left, right) => left.target.order - right.target.order ||
+        left.workbenchId.localeCompare(right.workbenchId));
     const defaultBundle = allowed.find((bundle) => bundle.target.isDefaultCandidate);
     if (defaultBundle)
-        return { status: 'resolved', bundle: defaultBundle, source: 'default' };
+        return { status: "resolved", bundle: defaultBundle, source: "default" };
     if (allowed[0])
-        return { status: 'resolved', bundle: allowed[0], source: 'first-accessible' };
-    return { status: 'forbidden', workbenchId: '' };
+        return {
+            status: "resolved",
+            bundle: allowed[0],
+            source: "first-accessible",
+        };
+    return { status: "forbidden", workbenchId: "" };
 };
 exports.resolveWorkbenchEntry = resolveWorkbenchEntry;
 //# sourceMappingURL=declarative-control-compiler.js.map