memeloop 0.2.3 → 0.2.5

package/dist/{chunk-GYIOMQMY.js → chunk-UB77WKAU.js}

@@ -1222,6 +1222,74 @@ function createArtifactManagementConformanceSuite(options) {
   };
 }
 
+// src/orchestration/drivers/driverState.ts
+function assertFencedDriverRequestEnvelope(request, options) {
+  assertDriverRequestEnvelope(request, {
+    now: options.now,
+    requireRun: options.requireRun,
+    requireFencing: true,
+    requireCapability: true,
+    expectedMethod: options.expectedMethod
+  });
+  if (options.actorKinds && !options.actorKinds.includes(request.actor.kind)) {
+    throw new OrchestrationError({
+      code: "FORBIDDEN",
+      message: options.forbiddenMessage?.(request.actor.kind) ?? `actor kind '${request.actor.kind}' cannot call ${options.expectedMethod}`,
+      retryable: false
+    });
+  }
+  const epoch = request.fencingEpoch;
+  const current = options.fences.get(request.resource.uid) ?? 0;
+  if (epoch < current) {
+    throw new OrchestrationError({
+      code: "STALE_EPOCH",
+      message: `stale ${options.fenceName} fencing epoch ${epoch}; current epoch is ${current}`,
+      retryable: false
+    });
+  }
+  options.fences.set(request.resource.uid, epoch);
+  return epoch;
+}
+function driverOperationKey(request, operation) {
+  return `${request.resource.uid}:${operation}:${request.idempotencyKey}`;
+}
+function findIdempotentDriverHandle(state, request, operation, driverName) {
+  const key = driverOperationKey(request, operation);
+  const handle = state.idempotency.get(key);
+  if (handle === void 0) return void 0;
+  if (state.idempotencyFingerprints.get(key) !== canonicalDriverValue(request.payload)) {
+    throw new OrchestrationError({
+      code: "CONFLICT",
+      message: `${driverName} ${operation} idempotency key was reused with different input`,
+      retryable: false
+    });
+  }
+  return handle;
+}
+function rememberIdempotentDriverHandle(state, request, operation, handle) {
+  const key = driverOperationKey(request, operation);
+  state.idempotency.set(key, handle);
+  state.idempotencyFingerprints.set(key, canonicalDriverValue(request.payload));
+}
+function getOwnedDriverValue(collection, handle, resourceUid, kind) {
+  const value = collection.get(handle);
+  if (!value) {
+    throw new OrchestrationError({
+      code: "NOT_FOUND",
+      message: `${kind} handle '${handle}' was not found`,
+      retryable: false
+    });
+  }
+  if (value.resourceUid !== resourceUid) {
+    throw new OrchestrationError({
+      code: "FORBIDDEN",
+      message: `${kind} handle '${handle}' belongs to another resource`,
+      retryable: false
+    });
+  }
+  return value;
+}
+
 // src/orchestration/drivers/auditTelemetryManagement.ts
 function createFakeAuditTelemetryState() {
   return {
@@ -1237,16 +1305,8 @@ var FORBIDDEN_ATTRIBUTE = /(?:secret|token|password|credential|authorization|coo
 function invalid3(message) {
   throw new OrchestrationError({ code: "INVALID", message, retryable: false });
 }
-function stable(value) {
-  if (value === void 0) return "undefined";
-  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stable(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? typeof value;
-}
 async function digest(value) {
-  const bytes = new TextEncoder().encode(stable(value));
+  const bytes = new TextEncoder().encode(canonicalDriverValue(value));
   const result = await globalThis.crypto.subtle.digest("SHA-256", bytes);
   return `sha256:${[...new Uint8Array(result)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
@@ -1264,29 +1324,13 @@ function createFakeAuditTelemetryManagementDriver(options = {}) {
   const maxRecordsPerResource = options.maxRecordsPerResource ?? 1e4;
   const maxAttributes = options.maxAttributes ?? 16;
   function validate(request, expectedMethod, actorKinds) {
-    assertDriverRequestEnvelope(request, {
+    assertFencedDriverRequestEnvelope(request, {
       now,
-      requireFencing: true,
-      requireCapability: true,
-      expectedMethod
+      fences: state.fences,
+      expectedMethod,
+      fenceName: "audit",
+      actorKinds
     });
-    if (!actorKinds.includes(request.actor.kind)) {
-      throw new OrchestrationError({
-        code: "FORBIDDEN",
-        message: `actor kind '${request.actor.kind}' cannot call ${expectedMethod}`,
-        retryable: false
-      });
-    }
-    const epoch = request.fencingEpoch;
-    const current = state.fences.get(request.resource.uid) ?? 0;
-    if (epoch < current) {
-      throw new OrchestrationError({
-        code: "STALE_EPOCH",
-        message: `stale audit fencing epoch ${epoch}; current epoch is ${current}`,
-        retryable: false
-      });
-    }
-    state.fences.set(request.resource.uid, epoch);
   }
   function common(request) {
     const policyDigest = requiredString2(request.payload, "policyDigest", 80);
@@ -1316,7 +1360,7 @@ function createFakeAuditTelemetryManagementDriver(options = {}) {
   }
   async function append(request, kind, data) {
     const idempotencyKey = `${request.resource.uid}:${request.method}:${request.idempotencyKey}`;
-    const fingerprint = stable(request.payload);
+    const fingerprint = canonicalDriverValue(request.payload);
     let release;
     const previousAppend = state.appendTail;
     state.appendTail = new Promise((resolve) => {
@@ -2437,24 +2481,6 @@ function requiredString4(payload, field) {
   if (payload === null || typeof payload !== "object" || typeof payload[field] !== "string" || !payload[field]) invalid5(`identity payload '${field}' is required`);
   return payload[field];
 }
-function owned(collection, handle, resourceUid, kind) {
-  const value = collection.get(handle);
-  if (!value) {
-    throw new OrchestrationError({
-      code: "NOT_FOUND",
-      message: `${kind} handle '${handle}' was not found`,
-      retryable: false
-    });
-  }
-  if (value.resourceUid !== resourceUid) {
-    throw new OrchestrationError({
-      code: "FORBIDDEN",
-      message: `${kind} handle '${handle}' belongs to another resource`,
-      retryable: false
-    });
-  }
-  return value;
-}
 function createFakeIdentityAttestationManagementDriver(options = {}) {
   const state = options.state ?? createFakeIdentityAttestationState();
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
@@ -2471,29 +2497,13 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
     `sha256:${"a".repeat(64)}`
   ];
   function validate(request, expectedMethod, actorKinds) {
-    assertDriverRequestEnvelope(request, {
+    assertFencedDriverRequestEnvelope(request, {
       now,
-      requireFencing: true,
-      requireCapability: true,
-      expectedMethod
+      fences: state.fences,
+      expectedMethod,
+      fenceName: "identity",
+      actorKinds
     });
-    if (!actorKinds.includes(request.actor.kind)) {
-      throw new OrchestrationError({
-        code: "FORBIDDEN",
-        message: `actor kind '${request.actor.kind}' cannot call ${expectedMethod}`,
-        retryable: false
-      });
-    }
-    const fence = request.fencingEpoch;
-    const current = state.fences.get(request.resource.uid) ?? 0;
-    if (fence < current) {
-      throw new OrchestrationError({
-        code: "STALE_EPOCH",
-        message: `stale identity fencing epoch ${fence}; current epoch is ${current}`,
-        retryable: false
-      });
-    }
-    state.fences.set(request.resource.uid, fence);
   }
   function ttl(payload, field, maximum) {
     if (payload === null || typeof payload !== "object") {
@@ -2508,34 +2518,11 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
     state.nextHandle += 1;
     return handle;
   }
-  function key(request, operation) {
-    return `${request.resource.uid}:${operation}:${request.idempotencyKey}`;
-  }
-  function stable6(value) {
-    if (value === void 0) return "undefined";
-    if (Array.isArray(value)) return `[${value.map(stable6).join(",")}]`;
-    if (value !== null && typeof value === "object") {
-      return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([name, item]) => `${JSON.stringify(name)}:${stable6(item)}`).join(",")}}`;
-    }
-    return JSON.stringify(value) ?? typeof value;
-  }
   function previous(request, operation) {
-    const idempotency = key(request, operation);
-    const handle = state.idempotency.get(idempotency);
-    if (!handle) return void 0;
-    if (state.idempotencyFingerprints.get(idempotency) !== stable6(request.payload)) {
-      throw new OrchestrationError({
-        code: "CONFLICT",
-        message: `identity ${operation} idempotency key was reused with different input`,
-        retryable: false
-      });
-    }
-    return handle;
+    return findIdempotentDriverHandle(state, request, operation, "identity");
   }
   function remember(request, operation, handle) {
-    const idempotency = key(request, operation);
-    state.idempotency.set(idempotency, handle);
-    state.idempotencyFingerprints.set(idempotency, stable6(request.payload));
+    rememberIdempotentDriverHandle(state, request, operation, handle);
   }
   function assertActiveIdentity(identity) {
     if (identity.revoked) {
@@ -2579,7 +2566,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
       const ttlMs = ttl(request.payload, "ttlMs", maxSessionTtlMs);
       const existing = previous(request, "enroll");
       if (existing) {
-        return structuredClone(owned(
+        return structuredClone(getOwnedDriverValue(
           state.enrollments,
           existing,
           request.resource.uid,
@@ -2603,7 +2590,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
     },
     async challenge(request) {
       validate(request, "identity.challenge", ["controller", "admin"]);
-      const enrollment = owned(
+      const enrollment = getOwnedDriverValue(
         state.enrollments,
         requiredString4(request.payload, "enrollmentHandle"),
         request.resource.uid,
@@ -2616,7 +2603,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
       const ttlMs = ttl(request.payload, "ttlMs", maxChallengeTtlMs);
       const existing = previous(request, "challenge");
       if (existing) {
-        return structuredClone(owned(
+        return structuredClone(getOwnedDriverValue(
           state.challenges,
           existing,
           request.resource.uid,
@@ -2646,13 +2633,13 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
     },
     async attest(request) {
       validate(request, "identity.attest", ["controller", "verifier"]);
-      const challenge = owned(
+      const challenge = getOwnedDriverValue(
         state.challenges,
         requiredString4(request.payload, "challengeHandle"),
         request.resource.uid,
         "challenge"
       );
-      const enrollment = owned(
+      const enrollment = getOwnedDriverValue(
         state.enrollments,
         challenge.enrollmentHandle,
         request.resource.uid,
@@ -2688,7 +2675,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
       }
       const existing = previous(request, "attest");
       if (existing) {
-        return structuredClone(owned(
+        return structuredClone(getOwnedDriverValue(
           state.identities,
           existing,
           request.resource.uid,
@@ -2723,7 +2710,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
     },
     async issueSession(request) {
       validate(request, "identity.issue-session", ["controller", "admin"]);
-      const identity = owned(
+      const identity = getOwnedDriverValue(
         state.identities,
         requiredString4(request.payload, "identityHandle"),
         request.resource.uid,
@@ -2752,7 +2739,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
       const ttlMs = ttl(request.payload, "ttlMs", maxSessionTtlMs);
       const existing = previous(request, "issue-session");
       if (existing) {
-        return structuredClone(owned(
+        return structuredClone(getOwnedDriverValue(
           state.sessions,
           existing,
           request.resource.uid,
@@ -2776,7 +2763,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
     },
     async rotate(request) {
       validate(request, "identity.rotate", ["controller", "admin"]);
-      const identity = owned(
+      const identity = getOwnedDriverValue(
         state.identities,
         requiredString4(request.payload, "identityHandle"),
         request.resource.uid,
@@ -2793,7 +2780,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
       );
       const existing = previous(request, "rotate");
       if (existing) {
-        return structuredClone(owned(
+        return structuredClone(getOwnedDriverValue(
           state.identities,
           existing,
           request.resource.uid,
@@ -2821,7 +2808,7 @@ function createFakeIdentityAttestationManagementDriver(options = {}) {
     },
     async revoke(request) {
       validate(request, "identity.revoke", ["controller", "admin"]);
-      const identity = owned(
+      const identity = getOwnedDriverValue(
         state.identities,
         requiredString4(request.payload, "identityHandle"),
         request.resource.uid,
@@ -3174,6 +3161,105 @@ function createIdentityAttestationConformanceSuite(options) {
   };
 }
 
+// src/orchestration/drivers/modelProviderDriver.ts
+var CLASSIFICATION_ORDER = {
+  public: 0,
+  internal: 1,
+  confidential: 2,
+  restricted: 3
+};
+function classificationRank(value) {
+  return CLASSIFICATION_ORDER[value];
+}
+function assertClassificationAllowed(policy, classification) {
+  if (!policy?.maxInputClassification || !classification) return;
+  if (classificationRank(classification) > classificationRank(policy.maxInputClassification)) {
+    throw new OrchestrationError({
+      code: "FORBIDDEN",
+      message: `input classification '${classification}' exceeds endpoint limit '${policy.maxInputClassification}'`,
+      retryable: false,
+      details: { classification, maxInputClassification: policy.maxInputClassification }
+    });
+  }
+}
+function modelClassNameForSpec(model) {
+  return `${model.provider}-${model.model}`.toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/^-+|-+$/g, "") || "model";
+}
+function createModelProviderDriverFromLLMProvider(provider, options) {
+  const inFlight = /* @__PURE__ */ new Map();
+  const toLegacyRequest = options.toLegacyRequest ?? ((request) => {
+    const candidates = options.models.filter(
+      (model) => modelClassNameForSpec(model) === request.modelClassRef.name || model.model === request.modelClassRef.name
+    );
+    if (candidates.length !== 1) {
+      throw new OrchestrationError({
+        code: "INVALID",
+        message: candidates.length === 0 ? `model class '${request.modelClassRef.name}' is not served by provider '${provider.name}'` : `model class '${request.modelClassRef.name}' is ambiguous for provider '${provider.name}'`,
+        retryable: false
+      });
+    }
+    return {
+      model: candidates[0].model,
+      messages: request.messages,
+      max_tokens: request.maxOutputTokens,
+      temperature: request.temperature,
+      topP: request.topP,
+      providerOptions: request.providerOptions,
+      abortSignal: request.signal
+    };
+  });
+  const toDelta = options.toDelta ?? ((chunk) => typeof chunk === "string" ? chunk : void 0);
+  return {
+    async listModels() {
+      return options.models;
+    },
+    async getHealth() {
+      return {
+        healthy: true,
+        detail: `legacy provider ${provider.name}`,
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    },
+    async *generate(request) {
+      assertClassificationAllowed(options.dataPolicy, request.inputClassification);
+      const controller = new AbortController();
+      inFlight.set(request.callId, controller);
+      const onExternalAbort = () => {
+        controller.abort();
+      };
+      request.signal?.addEventListener("abort", onExternalAbort);
+      try {
+        const legacy = toLegacyRequest({ ...request, signal: controller.signal });
+        const output = await provider.chat(legacy);
+        if (output != null && typeof output === "object" && Symbol.asyncIterator in output) {
+          for await (const chunk of output) {
+            if (controller.signal.aborted) {
+              yield {
+                type: "error",
+                error: { code: "CANCELLED", message: "generate cancelled", retryable: false }
+              };
+              return;
+            }
+            const delta = toDelta(chunk);
+            if (delta !== void 0) {
+              yield { type: "delta", delta };
+            }
+          }
+        } else if (typeof output === "string") {
+          yield { type: "delta", delta: output };
+        }
+        yield { type: "done" };
+      } finally {
+        request.signal?.removeEventListener("abort", onExternalAbort);
+        inFlight.delete(request.callId);
+      }
+    },
+    async cancel(callId) {
+      inFlight.get(callId)?.abort();
+    }
+  };
+}
+
 // src/orchestration/drivers/loopRuntimeManagement.ts
 function createFakeLoopRuntimeState() {
   return {
@@ -4001,12 +4087,12 @@ function createManagedCredentialBrokerAdapter(broker, options) {
           retryable: false
         });
       }
-      const stable6 = options.stableHandleFor?.(request) ?? stableHandle();
-      if (!stable6 || stable6.length > 2048) {
+      const stable = options.stableHandleFor?.(request) ?? stableHandle();
+      if (!stable || stable.length > 2048) {
         invalid6("credential stable handle is empty or too long");
       }
       if (options.handleStore) {
-        const adopted = await options.handleStore.get(stable6);
+        const adopted = await options.handleStore.get(stable);
         if (adopted) {
           const inspection = await broker.inspect(adopted.token);
           const exact = inspection.grantId === request.resource.uid && canonicalDriverValue(inspection.scope) === canonicalDriverValue({
@@ -4026,13 +4112,13 @@ function createManagedCredentialBrokerAdapter(broker, options) {
             });
           }
           const adoptedRecord = {
-            stableHandle: stable6,
+            stableHandle: stable,
             token: adopted.token,
             resourceUid: request.resource.uid,
             targetDriver: request.payload.targetDriver
           };
-          records.set(stable6, adoptedRecord);
-          await rememberIdempotency(key, request, stable6);
+          records.set(stable, adoptedRecord);
+          await rememberIdempotency(key, request, stable);
           return managed(adoptedRecord, inspection);
         }
       }
@@ -4048,7 +4134,7 @@ function createManagedCredentialBrokerAdapter(broker, options) {
         grantId: request.resource.uid
       });
       const record2 = {
-        stableHandle: stable6,
+        stableHandle: stable,
         token: issued.token,
         resourceUid: request.resource.uid,
         targetDriver: request.payload.targetDriver
@@ -4700,88 +4786,6 @@ function createManagedLoopRuntimeExecutionRoute(executionDriver, options) {
   };
 }
 
-// src/orchestration/drivers/modelProviderDriver.ts
-var CLASSIFICATION_ORDER = {
-  public: 0,
-  internal: 1,
-  confidential: 2,
-  restricted: 3
-};
-function classificationRank(value) {
-  return CLASSIFICATION_ORDER[value];
-}
-function assertClassificationAllowed(policy, classification) {
-  if (!policy?.maxInputClassification || !classification) return;
-  if (classificationRank(classification) > classificationRank(policy.maxInputClassification)) {
-    throw new OrchestrationError({
-      code: "FORBIDDEN",
-      message: `input classification '${classification}' exceeds endpoint limit '${policy.maxInputClassification}'`,
-      retryable: false,
-      details: { classification, maxInputClassification: policy.maxInputClassification }
-    });
-  }
-}
-function createModelProviderDriverFromLLMProvider(provider, options) {
-  const inFlight = /* @__PURE__ */ new Map();
-  const toLegacyRequest = options.toLegacyRequest ?? ((request) => ({
-    ...provider.modelId !== void 0 ? { model: provider.modelId } : {},
-    messages: request.messages,
-    max_tokens: request.maxOutputTokens,
-    temperature: request.temperature,
-    abortSignal: request.signal
-  }));
-  const toDelta = options.toDelta ?? ((chunk) => typeof chunk === "string" ? chunk : void 0);
-  return {
-    async listModels() {
-      return options.models;
-    },
-    async getHealth() {
-      return {
-        healthy: true,
-        detail: `legacy provider ${provider.name}`,
-        checkedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    },
-    async *generate(request) {
-      assertClassificationAllowed(options.dataPolicy, request.inputClassification);
-      const controller = new AbortController();
-      inFlight.set(request.callId, controller);
-      const onExternalAbort = () => {
-        controller.abort();
-      };
-      request.signal?.addEventListener("abort", onExternalAbort);
-      try {
-        const legacy = toLegacyRequest({ ...request, signal: controller.signal });
-        const output = await provider.chat(legacy);
-        if (output != null && typeof output === "object" && Symbol.asyncIterator in output) {
-          for await (const chunk of output) {
-            if (controller.signal.aborted) {
-              yield {
-                type: "error",
-                error: { code: "CANCELLED", message: "generate cancelled", retryable: false }
-              };
-              return;
-            }
-            const delta = toDelta(chunk);
-            if (delta !== void 0) {
-              yield { type: "delta", delta };
-            }
-          }
-        } else if (typeof output === "string") {
-          yield { type: "delta", delta: output };
-        }
-        yield { type: "done" };
-      } finally {
-        request.signal?.removeEventListener("abort", onExternalAbort);
-        inFlight.delete(request.callId);
-      }
-    },
-    async cancel(callId) {
-      inFlight.get(callId)?.abort();
-    }
-  };
-}
-
 // src/orchestration/drivers/managedModelGatewayAdapter.ts
 var SHA2562 = /^sha256:[a-f0-9]{64}$/;
 var CLASSIFICATIONS = ["public", "internal", "confidential", "restricted"];
@@ -5269,13 +5273,6 @@ function createFakeNetworkManagementState() {
     nextHandle: 1
   };
 }
-function stable2(value) {
-  if (Array.isArray(value)) return `[${value.map(stable2).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stable2(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? typeof value;
-}
 function invalid7(message) {
   throw new OrchestrationError({ code: "INVALID", message, retryable: false });
 }
@@ -5476,31 +5473,15 @@ function createFakeNetworkManagementDriver(options = {}) {
     ...options.capabilities
   };
   function validate(request, method) {
-    assertDriverRequestEnvelope(request, {
+    return assertFencedDriverRequestEnvelope(request, {
       now,
+      fences: state.fences,
       requireRun: true,
-      requireFencing: true,
-      requireCapability: true,
-      expectedMethod: method
+      expectedMethod: method,
+      fenceName: "network",
+      actorKinds: ["controller", "admin"],
+      forbiddenMessage: () => "network lifecycle requires a controller or admin actor"
     });
-    if (request.actor.kind !== "controller" && request.actor.kind !== "admin") {
-      throw new OrchestrationError({
-        code: "FORBIDDEN",
-        message: "network lifecycle requires a controller or admin actor",
-        retryable: false
-      });
-    }
-    const fence = request.fencingEpoch;
-    const current = state.fences.get(request.resource.uid) ?? 0;
-    if (fence < current) {
-      throw new OrchestrationError({
-        code: "STALE_EPOCH",
-        message: `stale network fencing epoch ${fence}; current epoch is ${current}`,
-        retryable: false
-      });
-    }
-    state.fences.set(request.resource.uid, fence);
-    return fence;
   }
   function nextHandle(prefix) {
     const handle = `${prefix}:${state.nextHandle}`;
@@ -5564,7 +5545,7 @@ function createFakeNetworkManagementDriver(options = {}) {
   }
   function idempotent(request, operation) {
     const key = `${request.resource.uid}:${operation}:${request.idempotencyKey}`;
-    const fingerprint = stable2(request.payload);
+    const fingerprint = canonicalDriverValue(request.payload);
     const existing = state.idempotency.get(key);
     if (existing) {
       if (existing.fingerprint !== fingerprint) {
@@ -5581,7 +5562,7 @@ function createFakeNetworkManagementDriver(options = {}) {
   function remember(request, operation, resultHandle) {
     state.idempotency.set(
       `${request.resource.uid}:${operation}:${request.idempotencyKey}`,
-      { fingerprint: stable2(request.payload), resultHandle }
+      { fingerprint: canonicalDriverValue(request.payload), resultHandle }
     );
   }
   return {
@@ -6146,18 +6127,10 @@ function requiredString6(value, field, maximum = 256) {
   if (!result || result.length > maximum) invalid8(`tool payload '${field}' is invalid`);
   return result;
 }
-function stable3(value) {
-  if (value === void 0) return "undefined";
-  if (Array.isArray(value)) return `[${value.map(stable3).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stable3(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? typeof value;
-}
 async function digest2(value) {
   const result = await globalThis.crypto.subtle.digest(
     "SHA-256",
-    new TextEncoder().encode(stable3(value))
+    new TextEncoder().encode(canonicalDriverValue(value))
   );
   return `sha256:${[...new Uint8Array(result)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
@@ -6240,37 +6213,21 @@ function createFakeToolManagementDriver(options = {}) {
         if (!SHA2565.test(descriptor.schemaDigest) || descriptor.schemaDigest !== actualSchemaDigest || !descriptor.name || !descriptor.version || !descriptor.targets.length) invalid8(`tool catalog descriptor '${descriptor.name}' is invalid`);
       }
       return digest2(
-        tools.map(descriptorInput).sort((left, right) => stable3(left).localeCompare(stable3(right)))
+        tools.map(descriptorInput).sort((left, right) => canonicalDriverValue(left).localeCompare(canonicalDriverValue(right)))
       );
     })();
     return catalogDigestPromise;
   }
   function validate(request, expectedMethod, actorKinds = ["controller"]) {
-    assertDriverRequestEnvelope(request, {
+    assertFencedDriverRequestEnvelope(request, {
       now,
-      requireFencing: true,
-      requireCapability: true,
-      expectedMethod
+      fences: state.fences,
+      expectedMethod,
+      fenceName: "tool",
+      actorKinds
     });
-    if (!actorKinds.includes(request.actor.kind)) {
-      throw new OrchestrationError({
-        code: "FORBIDDEN",
-        message: `actor kind '${request.actor.kind}' cannot call ${expectedMethod}`,
-        retryable: false
-      });
-    }
-    const epoch = request.fencingEpoch;
-    const current = state.fences.get(request.resource.uid) ?? 0;
-    if (epoch < current) {
-      throw new OrchestrationError({
-        code: "STALE_EPOCH",
-        message: `stale tool fencing epoch ${epoch}; current epoch is ${current}`,
-        retryable: false
-      });
-    }
-    state.fences.set(request.resource.uid, epoch);
   }
-  function owned2(collection, handle, resourceUid, kind) {
+  function owned(collection, handle, resourceUid, kind) {
     const value = collection.get(handle);
     if (!value) {
       throw new OrchestrationError({
@@ -6295,21 +6252,10 @@ function createFakeToolManagementDriver(options = {}) {
     return `${prefix}:${state.nextHandle++}`;
   }
   function idempotency(request, operation) {
-    const key = `${request.resource.uid}:${operation}:${request.idempotencyKey}`;
-    const previous = state.idempotency.get(key);
-    if (previous && state.idempotencyFingerprints.get(key) !== stable3(request.payload)) {
-      throw new OrchestrationError({
-        code: "CONFLICT",
-        message: `tool ${operation} idempotency key was reused with different input`,
-        retryable: false
-      });
-    }
-    return previous;
+    return findIdempotentDriverHandle(state, request, operation, "tool");
   }
   function remember(request, operation, handle) {
-    const key = `${request.resource.uid}:${operation}:${request.idempotencyKey}`;
-    state.idempotency.set(key, handle);
-    state.idempotencyFingerprints.set(key, stable3(request.payload));
+    rememberIdempotentDriverHandle(state, request, operation, handle);
   }
   async function* defaultExecutor(descriptor, target, arguments_) {
     yield JSON.stringify({ tool: descriptor.name, target, arguments: arguments_ });
@@ -6392,7 +6338,7 @@ function createFakeToolManagementDriver(options = {}) {
       if (request.payload.operationIdempotencyKey && !descriptor.supportsIdempotency) invalid8("tool does not support operation idempotency");
       const previous = idempotency(request, "prepare");
       if (previous) {
-        return structuredClone(owned2(
+        return structuredClone(owned(
           state.preparations,
           previous,
           request.resource.uid,
@@ -6417,7 +6363,7 @@ function createFakeToolManagementDriver(options = {}) {
     },
     async authorize(request) {
       validate(request, "tool.authorize", ["controller", "admin"]);
-      const preparation = owned2(
+      const preparation = owned(
         state.preparations,
         requiredString6(request.payload, "preparationHandle"),
         request.resource.uid,
@@ -6448,7 +6394,7 @@ function createFakeToolManagementDriver(options = {}) {
       }
       const previous = idempotency(request, "authorize");
       if (previous) {
-        return structuredClone(owned2(
+        return structuredClone(owned(
           state.authorizations,
           previous,
           request.resource.uid,
@@ -6470,13 +6416,13 @@ function createFakeToolManagementDriver(options = {}) {
     },
     async *invoke(request, invokeOptions = {}) {
       validate(request, "tool.invoke");
-      const preparation = owned2(
+      const preparation = owned(
         state.preparations,
         requiredString6(request.payload, "preparationHandle"),
         request.resource.uid,
         "tool preparation"
       );
-      const authorization = owned2(
+      const authorization = owned(
         state.authorizations,
         requiredString6(request.payload, "authorizationHandle"),
         request.resource.uid,
@@ -6496,7 +6442,7 @@ function createFakeToolManagementDriver(options = {}) {
       }
       const previous = idempotency(request, "invoke");
       if (previous) {
-        const execution2 = owned2(
+        const execution2 = owned(
           state.executions,
           previous,
           request.resource.uid,
@@ -6601,14 +6547,14 @@ function createFakeToolManagementDriver(options = {}) {
     },
     async reconcileUnknownEffect(request) {
       validate(request, "tool.reconcile-unknown", ["controller", "verifier", "admin"]);
-      const execution = owned2(
+      const execution = owned(
         state.executions,
         requiredString6(request.payload, "executionHandle"),
         request.resource.uid,
         "tool execution"
       );
       if (execution.phase !== "Unknown") return structuredClone(execution);
-      const preparation = owned2(
+      const preparation = owned(
         state.preparations,
         execution.preparationHandle,
         request.resource.uid,
@@ -6634,14 +6580,14 @@ function createFakeToolManagementDriver(options = {}) {
     },
     async collectEvidence(request) {
       validate(request, "tool.collect-evidence", ["controller", "verifier", "admin"]);
-      const execution = owned2(
+      const execution = owned(
         state.executions,
         requiredString6(request.payload, "executionHandle"),
         request.resource.uid,
         "tool execution"
       );
       const descriptor = tool(
-        owned2(
+        owned(
           state.preparations,
           execution.preparationHandle,
           request.resource.uid,
@@ -6651,7 +6597,7 @@ function createFakeToolManagementDriver(options = {}) {
       if (!descriptor?.supportsEvidence) invalid8("tool does not support evidence");
       const previous = idempotency(request, "evidence");
       if (previous) {
-        return structuredClone(owned2(
+        return structuredClone(owned(
           state.evidence,
           previous,
           request.resource.uid,
@@ -6672,14 +6618,14 @@ function createFakeToolManagementDriver(options = {}) {
     },
     async cleanup(request) {
       validate(request, "tool.cleanup");
-      const preparation = owned2(
+      const preparation = owned(
         state.preparations,
         requiredString6(request.payload, "preparationHandle"),
         request.resource.uid,
         "tool preparation"
       );
       if (request.payload.executionHandle) {
-        const execution = owned2(
+        const execution = owned(
           state.executions,
           request.payload.executionHandle,
           request.resource.uid,
@@ -6838,7 +6784,7 @@ function createToolManagementConformanceSuite(options) {
             { executionHandle: first[0].executionHandle },
             "inspect-invoke"
           ));
-          if (!first.at(-1)?.final || stable3(first) !== stable3(replay) || execution?.phase !== "Completed") throw new Error("tool streaming or retry did not converge");
+          if (!first.at(-1)?.final || canonicalDriverValue(first) !== canonicalDriverValue(replay) || execution?.phase !== "Completed") throw new Error("tool streaming or retry did not converge");
         }
       },
       {
@@ -7012,14 +6958,6 @@ function createFakeModelManagementState() {
     nextHandle: 1
   };
 }
-function stable4(value) {
-  if (value === void 0) return "undefined";
-  if (Array.isArray(value)) return `[${value.map(stable4).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stable4(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? typeof value;
-}
 function invalid9(message) {
   throw new OrchestrationError({ code: "INVALID", message, retryable: false });
 }
@@ -7078,31 +7016,15 @@ function createFakeModelManagementDriver(options = {}) {
   };
   const active = /* @__PURE__ */ new Map();
   function validate(request, method) {
-    assertDriverRequestEnvelope(request, {
+    return assertFencedDriverRequestEnvelope(request, {
       now,
+      fences: state.fences,
       requireRun: true,
-      requireFencing: true,
-      requireCapability: true,
-      expectedMethod: method
+      expectedMethod: method,
+      fenceName: "model",
+      actorKinds: ["controller", "admin"],
+      forbiddenMessage: () => "model provider access requires a controller or admin actor"
     });
-    if (request.actor.kind !== "controller" && request.actor.kind !== "admin") {
-      throw new OrchestrationError({
-        code: "FORBIDDEN",
-        message: "model provider access requires a controller or admin actor",
-        retryable: false
-      });
-    }
-    const fence = request.fencingEpoch;
-    const current = state.fences.get(request.resource.uid) ?? 0;
-    if (fence < current) {
-      throw new OrchestrationError({
-        code: "STALE_EPOCH",
-        message: `stale model fencing epoch ${fence}; current epoch is ${current}`,
-        retryable: false
-      });
-    }
-    state.fences.set(request.resource.uid, fence);
-    return fence;
   }
   function modelFor(payload) {
     assertOnlyFields2(
@@ -7229,7 +7151,7 @@ function createFakeModelManagementDriver(options = {}) {
       const fence = validate(request, "model.generate");
       const model = modelFor(request.payload);
       await authorize(request, model);
-      const inputFingerprint = stable4({
+      const inputFingerprint = canonicalDriverValue({
         payload: request.payload,
         run: request.run,
         session: request.session,
@@ -7468,7 +7390,9 @@ function createModelManagementConformanceSuite(options) {
           );
           const first = await collect(driver, request);
           const second = await collect(driver, request);
-          if (stable4(first) !== stable4(second)) throw new Error("model generation did not replay");
+          if (canonicalDriverValue(first) !== canonicalDriverValue(second)) {
+            throw new Error("model generation did not replay");
+          }
           if (first.at(-1)?.type !== "done") throw new Error("model stream did not complete");
           let driftRejected = false;
           try {
@@ -7602,16 +7526,8 @@ function requiredString7(value, field) {
   if (value === null || typeof value !== "object" || typeof value[field] !== "string" || !value[field]) invalid10(`policy payload '${field}' is required`);
   return value[field];
 }
-function stable5(value) {
-  if (value === void 0) return "undefined";
-  if (Array.isArray(value)) return `[${value.map(stable5).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stable5(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value) ?? typeof value;
-}
 async function digest3(value) {
-  const bytes = new TextEncoder().encode(stable5(value));
+  const bytes = new TextEncoder().encode(canonicalDriverValue(value));
   const result = await globalThis.crypto.subtle.digest("SHA-256", bytes);
   return `sha256:${[...new Uint8Array(result)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
@@ -7632,34 +7548,18 @@ function createFakePolicyApprovalManagementDriver(options = {}) {
     ]
   );
   function validate(request, expectedMethod, actorKinds) {
-    assertDriverRequestEnvelope(request, {
+    assertFencedDriverRequestEnvelope(request, {
       now,
-      requireFencing: true,
-      requireCapability: true,
-      expectedMethod
+      fences: state.fences,
+      expectedMethod,
+      fenceName: "policy",
+      actorKinds
     });
-    if (!actorKinds.includes(request.actor.kind)) {
-      throw new OrchestrationError({
-        code: "FORBIDDEN",
-        message: `actor kind '${request.actor.kind}' cannot call ${expectedMethod}`,
-        retryable: false
-      });
-    }
-    const epoch = request.fencingEpoch;
-    const current = state.fences.get(request.resource.uid) ?? 0;
-    if (epoch < current) {
-      throw new OrchestrationError({
-        code: "STALE_EPOCH",
-        message: `stale policy fencing epoch ${epoch}; current epoch is ${current}`,
-        retryable: false
-      });
-    }
-    state.fences.set(request.resource.uid, epoch);
   }
   function assertPolicyDigest(value) {
     if (!SHA2567.test(value)) invalid10("policyDigest must be a canonical sha256 digest");
   }
-  function owned2(handle, resourceUid) {
+  function owned(handle, resourceUid) {
     const decision = state.decisions.get(handle);
     if (!decision) {
       throw new OrchestrationError({
@@ -7679,18 +7579,14 @@ function createFakePolicyApprovalManagementDriver(options = {}) {
   }
   async function decide(request, operation, kind, outcome, policyDigest, reasons, obligations = [], approval) {
     assertPolicyDigest(policyDigest);
-    const key = `${request.resource.uid}:${operation}:${request.idempotencyKey}`;
-    const fingerprint = stable5(request.payload);
-    const previousHandle = state.idempotency.get(key);
+    const previousHandle = findIdempotentDriverHandle(
+      state,
+      request,
+      operation,
+      "policy"
+    );
     if (previousHandle) {
-      if (state.idempotencyFingerprints.get(key) !== fingerprint) {
-        throw new OrchestrationError({
-          code: "CONFLICT",
-          message: `policy ${operation} idempotency key was reused with different input`,
-          retryable: false
-        });
-      }
-      return structuredClone(owned2(previousHandle, request.resource.uid));
+      return structuredClone(owned(previousHandle, request.resource.uid));
     }
     const decision = {
       decisionHandle: `policy-decision:${state.nextHandle++}`,
@@ -7706,8 +7602,12 @@ function createFakePolicyApprovalManagementDriver(options = {}) {
       approval
     };
     state.decisions.set(decision.decisionHandle, decision);
-    state.idempotency.set(key, decision.decisionHandle);
-    state.idempotencyFingerprints.set(key, fingerprint);
+    rememberIdempotentDriverHandle(
+      state,
+      request,
+      operation,
+      decision.decisionHandle
+    );
     return structuredClone(decision);
   }
   return {
@@ -7780,7 +7680,7 @@ function createFakePolicyApprovalManagementDriver(options = {}) {
       }
       let approval;
       if (request.payload.approvalDecisionHandle) {
-        approval = owned2(request.payload.approvalDecisionHandle, request.resource.uid);
+        approval = owned(request.payload.approvalDecisionHandle, request.resource.uid);
       }
       const needsApproval = effect !== "read";
       const approvalValid = !needsApproval || approval?.kind === "approval" && approval.outcome === "allow" && approval.policyDigest === policyDigest && approval.approval?.subjectDigest === operationDigest && Date.parse(approval.approval.expiresAt) > now().getTime();
@@ -7828,7 +7728,7 @@ function createFakePolicyApprovalManagementDriver(options = {}) {
       if (!["allow", "deny"].includes(request.payload.outcome)) {
         invalid10("approval outcome must be allow or deny");
       }
-      const decision = owned2(handle, request.resource.uid);
+      const decision = owned(handle, request.resource.uid);
       if (decision.kind !== "approval") invalid10("decision is not an approval");
       if (decision.approval && Date.parse(decision.approval.expiresAt) <= now().getTime()) {
         decision.outcome = "deny";
@@ -7891,7 +7791,7 @@ function createFakePolicyApprovalManagementDriver(options = {}) {
         "verifier",
         "admin"
       ]);
-      const decision = owned2(
+      const decision = owned(
         requiredString7(request.payload, "decisionHandle"),
         request.resource.uid
       );
@@ -8128,6 +8028,7 @@ function createFakeStorageManagementState() {
     stages: /* @__PURE__ */ new Map(),
     publications: /* @__PURE__ */ new Map(),
     idempotency: /* @__PURE__ */ new Map(),
+    idempotencyFingerprints: /* @__PURE__ */ new Map(),
     fences: /* @__PURE__ */ new Map(),
     nextHandle: 1
   };
@@ -8155,32 +8056,18 @@ function createFakeStorageManagementDriver(options = {}) {
   const state = options.state ?? createFakeStorageManagementState();
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
   function validate(request, expectedMethod) {
-    assertDriverRequestEnvelope(request, {
+    return assertFencedDriverRequestEnvelope(request, {
       now,
-      requireFencing: true,
-      requireCapability: true,
-      expectedMethod
+      fences: state.fences,
+      expectedMethod,
+      fenceName: "storage"
     });
-    const fence = request.fencingEpoch;
-    const current = state.fences.get(request.resource.uid) ?? 0;
-    if (fence < current) {
-      throw new OrchestrationError({
-        code: "STALE_EPOCH",
-        message: `stale storage fencing epoch ${fence}; current epoch is ${current}`,
-        retryable: false
-      });
-    }
-    state.fences.set(request.resource.uid, fence);
-    return fence;
   }
   function nextHandle(prefix) {
     const handle = `${prefix}:${state.nextHandle}`;
     state.nextHandle += 1;
     return handle;
   }
-  function operationKey(request, operation) {
-    return `${request.resource.uid}:${operation}:${request.idempotencyKey}`;
-  }
   function getVolume(handle, resourceUid) {
     const record2 = state.volumes.get(handle);
     if (!record2 || record2.volume.phase === "Deleted") {
@@ -8199,27 +8086,8 @@ function createFakeStorageManagementDriver(options = {}) {
     }
     return record2;
   }
-  function owned2(collection, handle, resourceUid, kind) {
-    const value = collection.get(handle);
-    if (!value) {
-      throw new OrchestrationError({
-        code: "NOT_FOUND",
-        message: `${kind} handle '${handle}' was not found`,
-        retryable: false
-      });
-    }
-    if (value.resourceUid !== resourceUid) {
-      throw new OrchestrationError({
-        code: "FORBIDDEN",
-        message: `${kind} handle '${handle}' belongs to another resource`,
-        retryable: false
-      });
-    }
-    return value;
-  }
   function createVolume(request, capacityBytes, accessMode, replicaCount, operation) {
-    const key = operationKey(request, operation);
-    const existing = state.idempotency.get(key);
+    const existing = findIdempotentDriverHandle(state, request, operation, "storage");
     if (existing) return getVolume(existing, request.resource.uid).volume;
     const volume = {
       volumeHandle: nextHandle("volume"),
@@ -8230,7 +8098,7 @@ function createFakeStorageManagementDriver(options = {}) {
       phase: "Available"
     };
     state.volumes.set(volume.volumeHandle, { volume, desiredReplicas: replicaCount });
-    state.idempotency.set(key, volume.volumeHandle);
+    rememberIdempotentDriverHandle(state, request, operation, volume.volumeHandle);
     return volume;
   }
   return {
@@ -8286,9 +8154,10 @@ function createFakeStorageManagementDriver(options = {}) {
       validate(request, "storage.snapshot");
       const volumeHandle = requiredString8(request.payload, "volumeHandle");
       getVolume(volumeHandle, request.resource.uid);
-      const key = operationKey(request, "snapshot");
-      const existing = state.idempotency.get(key);
-      if (existing) return owned2(state.snapshots, existing, request.resource.uid, "snapshot");
+      const existing = findIdempotentDriverHandle(state, request, "snapshot", "storage");
+      if (existing) {
+        return getOwnedDriverValue(state.snapshots, existing, request.resource.uid, "snapshot");
+      }
       const snapshot = {
         snapshotHandle: nextHandle("snapshot"),
         volumeHandle,
@@ -8296,12 +8165,12 @@ function createFakeStorageManagementDriver(options = {}) {
         createdAt: now().toISOString()
       };
       state.snapshots.set(snapshot.snapshotHandle, snapshot);
-      state.idempotency.set(key, snapshot.snapshotHandle);
+      rememberIdempotentDriverHandle(state, request, "snapshot", snapshot.snapshotHandle);
       return snapshot;
     },
     async restoreSnapshot(request) {
       validate(request, "storage.restore");
-      const snapshot = owned2(
+      const snapshot = getOwnedDriverValue(
         state.snapshots,
         requiredString8(request.payload, "snapshotHandle"),
         request.resource.uid,
@@ -8364,9 +8233,10 @@ function createFakeStorageManagementDriver(options = {}) {
       validate(request, "storage.backup");
       const volumeHandle = requiredString8(request.payload, "volumeHandle");
       getVolume(volumeHandle, request.resource.uid);
-      const key = operationKey(request, "backup");
-      const existing = state.idempotency.get(key);
-      if (existing) return owned2(state.backups, existing, request.resource.uid, "backup");
+      const existing = findIdempotentDriverHandle(state, request, "backup", "storage");
+      if (existing) {
+        return getOwnedDriverValue(state.backups, existing, request.resource.uid, "backup");
+      }
       const backup = {
         backupHandle: nextHandle("backup"),
         volumeHandle,
@@ -8374,7 +8244,7 @@ function createFakeStorageManagementDriver(options = {}) {
         createdAt: now().toISOString()
       };
       state.backups.set(backup.backupHandle, backup);
-      state.idempotency.set(key, backup.backupHandle);
+      rememberIdempotentDriverHandle(state, request, "backup", backup.backupHandle);
       return backup;
     },
     async stage(request) {
@@ -8382,9 +8252,10 @@ function createFakeStorageManagementDriver(options = {}) {
       const volumeHandle = requiredString8(request.payload, "volumeHandle");
       getVolume(volumeHandle, request.resource.uid);
       const nodeId = requiredString8(request.payload, "nodeId");
-      const key = operationKey(request, "stage");
-      const existing = state.idempotency.get(key);
-      if (existing) return owned2(state.stages, existing, request.resource.uid, "stage");
+      const existing = findIdempotentDriverHandle(state, request, "stage", "storage");
+      if (existing) {
+        return getOwnedDriverValue(state.stages, existing, request.resource.uid, "stage");
+      }
       const stage = {
         stageHandle: nextHandle("stage"),
         volumeHandle,
@@ -8392,12 +8263,12 @@ function createFakeStorageManagementDriver(options = {}) {
         nodeId
       };
       state.stages.set(stage.stageHandle, stage);
-      state.idempotency.set(key, stage.stageHandle);
+      rememberIdempotentDriverHandle(state, request, "stage", stage.stageHandle);
       return stage;
     },
     async publish(request) {
       validate(request, "storage.publish");
-      const stage = owned2(
+      const stage = getOwnedDriverValue(
         state.stages,
         requiredString8(request.payload, "stageHandle"),
         request.resource.uid,
@@ -8406,10 +8277,14 @@ function createFakeStorageManagementDriver(options = {}) {
       getVolume(stage.volumeHandle, request.resource.uid);
       const workloadUid = requiredString8(request.payload, "workloadUid");
       if (typeof request.payload.readOnly !== "boolean") invalid11("publish readOnly is required");
-      const key = operationKey(request, "publish");
-      const existing = state.idempotency.get(key);
+      const existing = findIdempotentDriverHandle(state, request, "publish", "storage");
       if (existing) {
-        return owned2(state.publications, existing, request.resource.uid, "publication");
+        return getOwnedDriverValue(
+          state.publications,
+          existing,
+          request.resource.uid,
+          "publication"
+        );
       }
       const publication = {
         publishHandle: nextHandle("publication"),
@@ -8419,7 +8294,7 @@ function createFakeStorageManagementDriver(options = {}) {
         readOnly: request.payload.readOnly
       };
       state.publications.set(publication.publishHandle, publication);
-      state.idempotency.set(key, publication.publishHandle);
+      rememberIdempotentDriverHandle(state, request, "publish", publication.publishHandle);
       return publication;
     },
     async unpublish(request) {
@@ -8427,7 +8302,7 @@ function createFakeStorageManagementDriver(options = {}) {
       const handle = requiredString8(request.payload, "publishHandle");
       const publication = state.publications.get(handle);
       if (!publication) return;
-      owned2(state.publications, handle, request.resource.uid, "publication");
+      getOwnedDriverValue(state.publications, handle, request.resource.uid, "publication");
       state.publications.delete(handle);
     },
     async unstage(request) {
@@ -8435,7 +8310,7 @@ function createFakeStorageManagementDriver(options = {}) {
       const handle = requiredString8(request.payload, "stageHandle");
       const stage = state.stages.get(handle);
       if (!stage) return;
-      owned2(state.stages, handle, request.resource.uid, "stage");
+      getOwnedDriverValue(state.stages, handle, request.resource.uid, "stage");
       if ([...state.publications.values()].some(
         (publication) => publication.stageHandle === handle
       )) {
@@ -8449,13 +8324,13 @@ function createFakeStorageManagementDriver(options = {}) {
     },
     async getStats(request) {
       validate(request, "storage.stats");
-      const publication = owned2(
+      const publication = getOwnedDriverValue(
         state.publications,
         requiredString8(request.payload, "publishHandle"),
         request.resource.uid,
         "publication"
       );
-      const stage = owned2(
+      const stage = getOwnedDriverValue(
         state.stages,
         publication.stageHandle,
         request.resource.uid,
@@ -8686,6 +8561,10 @@ export {
   createFakeIdentityAttestationState,
   createFakeIdentityAttestationManagementDriver,
   createIdentityAttestationConformanceSuite,
+  classificationRank,
+  assertClassificationAllowed,
+  modelClassNameForSpec,
+  createModelProviderDriverFromLLMProvider,
   createFakeLoopRuntimeState,
   createFakeLoopRuntimeManagementDriver,
   createLoopRuntimeManagementConformanceSuite,
@@ -8695,9 +8574,6 @@ export {
   createManagedCredentialBrokerAdapter,
   createManagedLoopRuntimeAdapter,
   createManagedLoopRuntimeExecutionRoute,
-  classificationRank,
-  assertClassificationAllowed,
-  createModelProviderDriverFromLLMProvider,
   createManagedModelGatewayAdapter,
   featuresRequiredByClass,
   canDriverSatisfyClass,
@@ -8723,4 +8599,4 @@ export {
   createFakeStorageManagementDriver,
   createStorageManagementConformanceSuite
 };
-//# sourceMappingURL=chunk-GYIOMQMY.js.map
+//# sourceMappingURL=chunk-UB77WKAU.js.map