rovloom 0.6.0 → 0.6.1

package/dist/src/{chunk-gyvqqnjb.js → chunk-enj7s8cv.js}

@@ -2,7 +2,7 @@
 import {
   cliMessages2,
   formatMessage2
-} from "./chunk-5b8g62kw.js";
+} from "./chunk-pgs9jp6t.js";
 import {
   readRuntimeConfig2
 } from "./chunk-bspzg8er.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-hpzr94hm.js";
 import {
   PRODUCT_VERSION2
-} from "./chunk-s3ydr65k.js";
+} from "./chunk-j59ac0xs.js";
 import {
   isWildcardHostname
 } from "./chunk-6n9s7nfe.js";
@@ -113,26 +113,43 @@ function parseCommand2(args, environment) {
     throw new CliError2("invalid_arguments");
   }
   const withoutNonInteractive = nonInteractive ? serviceArgs.slice(0, -1) : serviceArgs;
-  const flag = withoutNonInteractive[1];
-  const repair = withoutNonInteractive[0] === "gateway" ? flag === "--repair-device" : flag === "--repair";
-  const addDevice = withoutNonInteractive[0] === "gateway" && flag === "--add-device";
-  const claim = withoutNonInteractive[0] === "connector" && flag === "--claim";
-  if ((repair || addDevice || claim) && nonInteractive) {
+  const role = withoutNonInteractive[0];
+  if (role !== "gateway" && role !== "connector") {
     throw new CliError2("invalid_arguments");
   }
-  const roleArgs = repair || addDevice || claim ? [withoutNonInteractive[0], ...withoutNonInteractive.slice(2)] : withoutNonInteractive;
-  if ((roleArgs[0] === "gateway" || roleArgs[0] === "connector") && (roleArgs.length === 1 || roleArgs.length === 3 && roleArgs[1] === "--config")) {
-    return {
-      action: roleArgs[0],
-      path: resolveRoleConfigPath2(roleArgs[0], roleArgs[2], environment),
-      ...nonInteractive ? { nonInteractive: true } : {},
-      ...serviceId ? { serviceId } : {},
-      ...repair ? { repair: true } : {},
-      ...addDevice ? { addDevice: true } : {},
-      ...claim ? { claim: true } : {}
-    };
+  let explicit;
+  let joinValue;
+  let issueCode = false;
+  let unpair = false;
+  for (let index = 1;index < withoutNonInteractive.length; index++) {
+    const option = withoutNonInteractive[index];
+    if (option === "--config" && explicit === undefined) {
+      explicit = withoutNonInteractive[++index];
+      if (explicit === undefined || explicit.startsWith("--")) {
+        throw new CliError2("invalid_arguments");
+      }
+    } else if (option === "--join" && role === "connector" && joinValue === undefined && !unpair) {
+      joinValue = withoutNonInteractive[++index];
+      if (joinValue === undefined || !/^wss?:\/\/[^#\s]+#[A-Za-z0-9_.-]+$/.test(joinValue)) {
+        throw new CliError2("invalid_arguments");
+      }
+    } else if (option === "--issue-code" && role === "gateway" && !issueCode) {
+      issueCode = true;
+    } else if (option === "--unpair" && role === "connector" && !unpair && joinValue === undefined) {
+      unpair = true;
+    } else {
+      throw new CliError2("invalid_arguments");
+    }
   }
-  throw new CliError2("invalid_arguments");
+  return {
+    action: role,
+    path: resolveRoleConfigPath2(role, explicit, environment),
+    ...nonInteractive ? { nonInteractive: true } : {},
+    ...serviceId ? { serviceId } : {},
+    ...joinValue !== undefined ? { join: joinValue } : {},
+    ...issueCode ? { issueCode: true } : {},
+    ...unpair ? { unpair: true } : {}
+  };
 }
 async function untilStopped(running, signal) {
   let wake;
@@ -152,7 +169,7 @@ async function untilStopped(running, signal) {
 async function runCli2(args, io, runtime = {}, environment) {
   try {
     if (args[0] === "service") {
-      const { handleServiceCommand } = await import("./chunk-g27b2gmx.js");
+      const { handleServiceCommand } = await import("./chunk-0e9gg4sg.js");
       if (args.length === 2 && args[1] === "--help") {
         io.stderr.write(cliMessages2(io.language)["help.service"]);
         return 0;
@@ -182,15 +199,15 @@ async function runCli2(args, io, runtime = {}, environment) {
       throw new CliError2("invalid_arguments");
     }
     if (args[0] === "admin") {
-      const { handleAdminCommand } = await import("./chunk-ytpfmcp1.js");
+      const { handleAdminCommand } = await import("./chunk-n3z3jaxy.js");
       return await handleAdminCommand(args, io, environment);
     }
     if (args[0] === "doctor" || args[0] === "storage") {
-      const { handleStorageCommand } = await import("./chunk-n6wtjyfb.js");
+      const { handleStorageCommand } = await import("./chunk-8c9yc0ge.js");
       return await handleStorageCommand(args, io, environment);
     }
     if (args[0] === "token") {
-      const { handleTokenCommand } = await import("./chunk-ssp57p43.js");
+      const { handleTokenCommand } = await import("./chunk-m76cmkfy.js");
       return await handleTokenCommand(args, io, environment);
     }
     if (args[0] === "config" && args[1] === "init") {
@@ -251,11 +268,14 @@ async function runCli2(args, io, runtime = {}, environment) {
     if (io.signal.aborted) {
       return 0;
     }
-    if (!command.nonInteractive) {
+    if (command.unpair) {
+      const { handleConnectorUnpair } = await import("./chunk-sqz614bh.js");
+      return await handleConnectorUnpair(command.path, io);
+    }
+    if (!command.nonInteractive || command.join !== undefined || command.issueCode) {
       config = await runtime.prepare?.(config, command.path, io, {
-        ...command.repair ? { repair: true } : {},
-        ...command.addDevice ? { addDevice: true } : {},
-        ...command.claim ? { claim: true } : {}
+        ...command.join !== undefined ? { join: command.join } : {},
+        ...command.issueCode ? { issueCode: true } : {}
       }) ?? config;
     }
     if (config.role !== command.action) {
@@ -285,7 +305,7 @@ async function runCli2(args, io, runtime = {}, environment) {
         io.stderr.write(cliMessages2(io.language)["run.wildcardListenWarning"]);
       }
       try {
-        const { startHttpFacade } = await import("./chunk-srfbjwtk.js");
+        const { startHttpFacade } = await import("./chunk-z0qmfqvd.js");
         const http = startHttpFacade({
           service: gateway.service,
           authentication: gateway.authentication,
@@ -349,4 +369,4 @@ pairing_required
 
 export { cliHelp2, parseCommand2, runCli2 };
 
-//# debugId=618C67B77D8D88C964756E2164756E21
+//# debugId=9F289B394757794864756E2164756E21

package/dist/src/{chunk-jka7v3wb.js → chunk-ftpy8xx3.js}

@@ -12,11 +12,13 @@ import {
   fields2,
   id2,
   uint2,
+  sha2,
   boundedJson2,
   parseJson2,
   hash2,
   validateTarget2,
   validateProvider2,
+  validateContractSource2,
   contractRef2,
   validatePolicies2,
   assertBinding2,
@@ -27,10 +29,10 @@ import {
   Router2
 } from "./chunk-y4hksha9.js";
 import {
-  LuvusAdapterError2,
   pinTerminalExecution
-} from "./chunk-57ayxqnb.js";
+} from "./chunk-8fy8w7ds.js";
 import {
+  compileBundle2,
   createNativeValidator2
 } from "./chunk-mqyq5jh6.js";
 import {
@@ -47,15 +49,17 @@ import {
   createConnector2,
   createDeviceLifecycle2,
   createDeviceLifecycleAdapter2
-} from "./chunk-zjzrcc59.js";
+} from "./chunk-59h200cr.js";
 import {
-  createLuvusRequestPreflight,
-  luvusValidation
-} from "./chunk-zj48jvfe.js";
+  LUVUS_OPERATION_METHODS2,
+  luvusOperationDescriptor2,
+  luvusOperationValidation2,
+  validateLuvusOperationParams2
+} from "./chunk-efty77sb.js";
 import {
   configuredSnapshotDirectory,
   Store2
-} from "./chunk-qjh9x872.js";
+} from "./chunk-av31bx1e.js";
 import {
   createProviderResultAccess2,
   LUVUS_ENDPOINT_TRANSPORT,
@@ -72,13 +76,13 @@ import {
   parseRpcFrame,
   LuvusRpcAdapter2,
   readLuvusPeer2
-} from "./chunk-0xgpxdgc.js";
+} from "./chunk-bbdtsg4b.js";
 import {
   CONNECTOR_MAX_DEADLINE_MS2,
   ConnectorAttemptBook2,
   createConnectorAdmissionBackend2,
   connectorAdmissionAdapter
-} from "./chunk-d4ejrtjq.js";
+} from "./chunk-6n6b1xpy.js";
 import {
   OwnedProcessShutdownError,
   observeLuvusProcess,
@@ -90,18 +94,22 @@ import {
   NativeInstanceContext,
   discoverLuvusInstallation,
   MANAGED_LUVUS_REVISION2,
+  MANAGED_LUVUS_CLASSIFICATION2,
   registerLocalOwnerLuvus,
   assertLocalOwnerLuvus,
   observedLuvusContract,
-  startManagedLuvus2,
-  assertLuvusOperationsContract,
-  createLuvusOperationsAuthority,
-  checkedRemoteLuvusConfig,
-  createPinnedRemoteLuvus
-} from "./chunk-5s2emvww.js";
+  startManagedLuvus2
+} from "./chunk-j6svdqr8.js";
+import {
+  createLuvusRequestPreflight,
+  luvusValidation
+} from "./chunk-xtvgm6kf.js";
 import {
   LuvusDispatchClaims2
-} from "./chunk-gbsbwssz.js";
+} from "./chunk-sf4ztxba.js";
+import {
+  LuvusAdapterError2
+} from "./chunk-pksaqt9a.js";
 import {
   agentSearchPath
 } from "./chunk-3nnahj0j.js";
@@ -2126,6 +2134,53 @@ function createManagementSessionAuthority2(source, options = {}) {
     close
   });
 }
+// src/runtime/luvus-operations-authority.ts
+import { isDeepStrictEqual } from "util";
+function assertLuvusOperationsContract(contract) {
+  const source = contract.wire.source;
+  const capabilities = object2(object2(contract.capabilities).result);
+  if (contract.wire.support_status !== "validated" || source.provider_kind !== "luvus" || source.protocol_family !== "uhp" || source.schema_origin !== "installed_cli" || source.schema_command !== "luvus uhp schema" || !/^1\.\d+$/u.test(source.native_protocol_version ?? "") || source.support_basis !== "live_catalog" || source.adapter_revision !== MANAGED_LUVUS_REVISION2 || source.classification_revision !== MANAGED_LUVUS_CLASSIFICATION2 || typeof source.runtime_generation !== "string" || !source.runtime_generation.length || source.runtime_generation !== capabilities.server_generation || contract.compiled.identity.binary_sha256 !== source.binary_sha256 || contract.compiled.identity.schema_sha256 !== source.schema_sha256 || contract.compiled.identity.revision !== source.adapter_revision || !Array.isArray(capabilities.method_contracts)) {
+    throw new LuvusAdapterError2("luvus_operations_source_mismatch");
+  }
+}
+function createLuvusOperationsAuthority(contract, current, rawAllowed) {
+  assertLuvusOperationsContract(contract);
+  const methods = object2(object2(contract.capabilities).result).method_contracts;
+  return (attempt, native) => {
+    const proven = current(attempt.binding);
+    const descriptor = luvusOperationDescriptor2(attempt.method);
+    if (proven.authenticated !== true || proven.source_verified !== true || !descriptor || attempt.native_request.method !== attempt.method || attempt.mode !== luvusOperationValidation2(attempt.method) || !isDeepStrictEqual(proven.binding, native)) {
+      throw new LuvusAdapterError2("luvus_operation_unreviewed");
+    }
+    const live = methods.filter((row) => row.method === attempt.method);
+    if (live.length !== 1 || !isDeepStrictEqual({
+      method: live[0].method,
+      access: live[0].access,
+      scope: live[0].scope,
+      idempotent: live[0].idempotent
+    }, descriptor.native)) {
+      throw new LuvusAdapterError2("luvus_operations_contract_mismatch");
+    }
+    validateLuvusOperationParams2(attempt.method, attempt.native_request.params);
+    const raw = attempt.mode === "raw-contract";
+    const allowed = raw && rawAllowed(attempt) === true;
+    return {
+      owner: allowed,
+      raw_requested: raw,
+      ...allowed ? {
+        raw_grant: {
+          id: attempt.binding.call_id,
+          source_verified: true,
+          principal_id: attempt.principal_id,
+          binding: native,
+          methods: [attempt.method],
+          expires_at: attempt.binding.registration.deadline
+        }
+      } : {}
+    };
+  };
+}
+
 // src/runtime/luvus-operations-provider.ts
 function createLuvusOperationsProvider2(owner, peerPolicyRevision) {
   assertLocalOwnerLuvus(owner);
@@ -2175,7 +2230,7 @@ function createLuvusOperationsProvider2(owner, peerPolicyRevision) {
 }
 // src/runtime/native-attach.ts
 import { randomUUID } from "crypto";
-import { isDeepStrictEqual } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 class AttachedLuvus extends NativeInstanceContext {
   #observation;
   #closed = false;
@@ -2254,7 +2309,7 @@ async function attachExistingLuvus2(config, options = {}) {
         bytes,
         beforeWrite() {
           observation.assertLive();
-          if (!isDeepStrictEqual(readLuvusPeer2(socket, endpoint), observation.identity())) {
+          if (!isDeepStrictEqual2(readLuvusPeer2(socket, endpoint), observation.identity())) {
             throw new LuvusAdapterError2("attached_peer_mismatch");
           }
         }
@@ -2279,7 +2334,7 @@ async function attachExistingLuvus2(config, options = {}) {
 }
 // src/runtime/production-luvus.ts
 import { join as join2 } from "path";
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "util";
 
 // src/runtime/luvus-user-source.ts
 import { spawn } from "child_process";
@@ -2458,6 +2513,239 @@ async function startUserLuvus(input) {
   });
 }
 
+// src/runtime/remote-luvus.ts
+function checkedRemoteLuvusConfig(reference, input) {
+  const config = object2(JSON.parse(boundedJson2(input)));
+  fields2(config, ["kind", "authentication", "binding", "target", "contract", "peer_policy_revision"], ["raw_grant"]);
+  validateProvider2(config.binding);
+  validateTarget2(config.target);
+  id2(config.peer_policy_revision);
+  const pin = object2(config.contract);
+  fields2(pin, [
+    "binary_version",
+    "binary_sha256",
+    "schema_sha256",
+    "adapter_revision",
+    "classification_revision",
+    "schema_bundle"
+  ]);
+  sha2(pin.binary_sha256);
+  sha2(pin.schema_sha256);
+  if (config.kind !== "luvus" || config.authentication !== "remote_connector" || config.binding.kind !== "luvus" || config.target.profile !== "session" || config.binding.machine_id !== config.target.machine_id || config.binding.provider_id !== config.target.provider_id || config.binding.config_ref !== reference || typeof pin.binary_version !== "string" || !pin.binary_version.length || pin.binary_version.length > 128 || pin.adapter_revision !== MANAGED_LUVUS_REVISION2 || pin.classification_revision !== MANAGED_LUVUS_CLASSIFICATION2 || typeof pin.schema_bundle !== "string" || hash2(pin.schema_bundle) !== pin.schema_sha256) {
+    throw new LuvusAdapterError2("remote_luvus_pin_invalid");
+  }
+  if (config.raw_grant !== undefined) {
+    const grant = object2(config.raw_grant);
+    fields2(grant, ["principal_id", "methods"]);
+    id2(grant.principal_id);
+    if (!Array.isArray(grant.methods) || grant.methods.length > LUVUS_OPERATION_METHODS2.length || new Set(grant.methods).size !== grant.methods.length || grant.methods.some((method) => !LUVUS_OPERATION_METHODS2.includes(method))) {
+      throw new LuvusAdapterError2("remote_luvus_raw_grant_invalid");
+    }
+    Object.freeze(grant.methods);
+    Object.freeze(grant);
+  }
+  Object.freeze(config.binding);
+  Object.freeze(config.target);
+  Object.freeze(pin);
+  return Object.freeze(config);
+}
+async function createPinnedRemoteLuvus(config) {
+  const pin = config.contract;
+  const compiled = await compileBundle2(Buffer.from(pin.schema_bundle), {
+    identity: { binary_sha256: pin.binary_sha256, schema_sha256: pin.schema_sha256, revision: pin.adapter_revision }
+  });
+  if (!compiled.ok) {
+    throw new LuvusAdapterError2(compiled.error.code);
+  }
+  const contractHandle = compiled.value;
+  const target = config.target;
+  if (target.profile !== "session") {
+    throw new LuvusAdapterError2("remote_luvus_pin_invalid");
+  }
+  const validator = createNativeValidator2(contractHandle);
+  let closed = false;
+  let active;
+  function assertEpoch(epoch) {
+    if (closed || epoch.closed || active !== epoch) {
+      throw new LuvusAdapterError2("remote_luvus_epoch_unavailable");
+    }
+    const checked = epoch.assertCurrent();
+    if (checked !== undefined) {
+      Promise.resolve(checked).catch(() => {});
+      throw new LuvusAdapterError2("synchronous_remote_source_required");
+    }
+    if (closed || epoch.closed || active !== epoch) {
+      throw new LuvusAdapterError2("remote_luvus_epoch_unavailable");
+    }
+  }
+  function closeEpoch(epoch) {
+    epoch.closed = true;
+    epoch.record = undefined;
+    epoch.provider = undefined;
+    if (active === epoch) {
+      active = undefined;
+    }
+  }
+  function nativeBinding(epoch, policies) {
+    assertEpoch(epoch);
+    const record = epoch.record;
+    if (!record) {
+      throw new LuvusAdapterError2("remote_luvus_snapshot_required");
+    }
+    id2(policies.caller_policy_revision);
+    id2(policies.local_policy_revision);
+    const target = config.target;
+    if (target.profile !== "session") {
+      throw new LuvusAdapterError2("remote_luvus_pin_invalid");
+    }
+    const binding = Object.freeze({
+      kind: "luvus",
+      provider_id: target.provider_id,
+      binding_revision: config.binding.binding_revision,
+      contract_source_ref: contractRef2(record.wire.source),
+      target: Object.freeze({ machine_id: target.machine_id, profile: "session", session: target.session }),
+      server_generation: record.wire.source.runtime_generation,
+      connection_epoch: epoch.connection.connection_epoch,
+      recovery_generation: epoch.connection.recovery_generation,
+      capability_revision: record.capability_revision,
+      caller_policy_revision: policies.caller_policy_revision,
+      local_policy_revision: policies.local_policy_revision,
+      classification_revision: pin.classification_revision,
+      contract: contractHandle.identity
+    });
+    assertEpoch(epoch);
+    return Object.freeze({ binding, authenticated: true, source_verified: true });
+  }
+  function ready() {
+    try {
+      if (!active?.record) {
+        return false;
+      }
+      assertEpoch(active);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  const provider = Object.freeze({
+    remote_luvus: true,
+    binding: config.binding,
+    target: config.target,
+    peer_policy_revision: config.peer_policy_revision,
+    preflightRequest: createLuvusRequestPreflight(contractHandle),
+    ready,
+    open(connection, assertCurrent) {
+      if (closed || active || !connection.authenticated || !connection.active || connection.machine_id !== config.target.machine_id || !connection.negotiated.capabilities.includes("provider_snapshot")) {
+        throw new LuvusAdapterError2("remote_luvus_epoch_unavailable");
+      }
+      const epoch = { connection: structuredClone(connection), assertCurrent, closed: false };
+      active = epoch;
+      try {
+        assertEpoch(epoch);
+      } catch (error) {
+        closeEpoch(epoch);
+        throw error;
+      }
+      return Object.freeze({
+        accept(input) {
+          assertEpoch(epoch);
+          const copied = parseNativeJson2(boundedJson2(input));
+          if (!copied.ok) {
+            throw new LuvusAdapterError2(copied.error.code);
+          }
+          const snapshot = copied.value;
+          fields2(object2(snapshot), ["binding", "target", "source", "capabilities", "capability_revision"]);
+          validateProvider2(snapshot.binding);
+          validateTarget2(snapshot.target);
+          validateContractSource2(snapshot.source);
+          sha2(snapshot.capability_revision);
+          if (boundedJson2(snapshot.binding) !== boundedJson2(config.binding) || boundedJson2(snapshot.target) !== boundedJson2(config.target)) {
+            throw new LuvusAdapterError2("remote_luvus_binding_mismatch");
+          }
+          const source = snapshot.source;
+          if (source.binary_sha256 !== pin.binary_sha256 || source.schema_sha256 !== pin.schema_sha256 || source.adapter_revision !== pin.adapter_revision || source.classification_revision !== pin.classification_revision || typeof source.runtime_generation !== "string" || !source.runtime_generation.length) {
+            throw new LuvusAdapterError2("remote_luvus_contract_mismatch");
+          }
+          const capabilities = object2(snapshot.capabilities);
+          const value = object2(capabilities.result);
+          if (hash2(boundedJson2(value)) !== snapshot.capability_revision) {
+            throw new LuvusAdapterError2("remote_luvus_capability_mismatch");
+          }
+          const shape = validator.checkCapabilitiesShape(capabilities, {
+            target: { machine_id: target.machine_id, profile: "session", session: target.session },
+            server_generation: source.runtime_generation
+          });
+          if (!shape.ok) {
+            throw new LuvusAdapterError2(shape.error.code);
+          }
+          const record = Object.freeze({
+            wire: Object.freeze({ source: Object.freeze(source), support_status: "validated" }),
+            compiled: contractHandle,
+            capabilities,
+            capability_revision: snapshot.capability_revision
+          });
+          assertLuvusOperationsContract(record);
+          const fingerprint = hash2(boundedJson2(snapshot));
+          if (epoch.fingerprint !== undefined) {
+            if (epoch.fingerprint !== fingerprint) {
+              throw new LuvusAdapterError2("remote_luvus_snapshot_changed");
+            }
+            assertEpoch(epoch);
+            return epoch.provider;
+          }
+          function sourceFor(binding) {
+            assertEpoch(epoch);
+            assertBinding2(binding, binding);
+            if (binding.machine_id !== epoch.connection.machine_id || binding.recovery_generation !== epoch.connection.recovery_generation || binding.connection_epoch !== epoch.connection.connection_epoch || binding.provider_kind !== "luvus" || binding.binding_revision !== config.binding.binding_revision || boundedJson2(binding.target) !== boundedJson2(config.target) || binding.contract_ref !== contractRef2(record.wire.source)) {
+              throw new LuvusAdapterError2("remote_luvus_binding_mismatch");
+            }
+            return nativeBinding(epoch, binding.registration);
+          }
+          const live = Object.freeze({
+            binding: config.binding,
+            target: config.target,
+            peer_policy_revision: config.peer_policy_revision,
+            contract: record,
+            source: sourceFor,
+            catalogSource(current, policies) {
+              if (boundedJson2(current) !== boundedJson2(epoch.connection)) {
+                throw new LuvusAdapterError2("remote_luvus_epoch_unavailable");
+              }
+              return nativeBinding(epoch, policies);
+            },
+            authority: createLuvusOperationsAuthority(record, sourceFor, (attempt) => config.raw_grant?.principal_id === attempt.principal_id && config.raw_grant.methods.includes(attempt.method)),
+            ready() {
+              try {
+                assertEpoch(epoch);
+                return !!epoch.record;
+              } catch {
+                return false;
+              }
+            }
+          });
+          assertEpoch(epoch);
+          epoch.record = record;
+          epoch.fingerprint = fingerprint;
+          epoch.provider = live;
+          return live;
+        },
+        close() {
+          closeEpoch(epoch);
+        }
+      });
+    }
+  });
+  return Object.freeze({
+    provider,
+    close() {
+      closed = true;
+      if (active) {
+        closeEpoch(active);
+      }
+    }
+  });
+}
+
 // src/runtime/production-luvus.ts
 function references(input, mode) {
   try {
@@ -2804,8 +3092,8 @@ function createLuvusProductionSources2() {
               routes,
               book,
               source: {
-                provider: (target) => isDeepStrictEqual2(target, fixed.target) ? provider.binding : undefined,
-                localProvider: (target) => isDeepStrictEqual2(target, fixed.target) ? provider.binding : undefined,
+                provider: (target) => isDeepStrictEqual3(target, fixed.target) ? provider.binding : undefined,
+                localProvider: (target) => isDeepStrictEqual3(target, fixed.target) ? provider.binding : undefined,
                 contract: (ref) => ref === reference ? provider.contract : undefined,
                 nativeSource: (call, attempt) => {
                   const row = admitted.backend?.attempt(call, attempt);
@@ -2867,6 +3155,6 @@ function createLuvusProductionSources2() {
     }
   });
 }
-export { createTrustedRequestScope2, composeGatewaySessions2, composeConnectorSessions2, createGatewayRuntime2, createProviderGatewayRuntime2, openGatewayState2, createLuvusConnectorSessions2, createConnectorRuntime2, ConnectorHostStartupError2, createProviderConnectorRuntime2, createManagementSessionAuthority2, createLuvusOperationsProvider2, attachExistingLuvus2, LuvusProductionStartupError2, createLuvusProductionSources2 };
+export { createTrustedRequestScope2, composeGatewaySessions2, composeConnectorSessions2, createGatewayRuntime2, createProviderGatewayRuntime2, openGatewayState2, createLuvusConnectorSessions2, createConnectorRuntime2, ConnectorHostStartupError2, createProviderConnectorRuntime2, createManagementSessionAuthority2, createLuvusOperationsProvider2, attachExistingLuvus2, checkedRemoteLuvusConfig, createPinnedRemoteLuvus, LuvusProductionStartupError2, createLuvusProductionSources2 };
 
-//# debugId=8FAF80F854C0B57664756E2164756E21
+//# debugId=A165CD691DA8923B64756E2164756E21

package/dist/src/{chunk-zdxww7ms.js → chunk-h3xyq7zk.js}

@@ -2,7 +2,7 @@
 import {
   currentProcessIdentity,
   ownerIsDead
-} from "./chunk-0pewfj89.js";
+} from "./chunk-qp8tgms2.js";
 import {
   syncParentDirectory
 } from "./chunk-0y5542k8.js";

package/dist/src/{chunk-ttsrctxg.js → chunk-hxmq28pg.js}

@@ -11,27 +11,29 @@ import {
   MessageWindow2
 } from "./chunk-g7pnjzkk.js";
 import {
-  LuvusAdapterError2,
-  ConnectorCapacityError,
   assertTerminalExecutionAllowed
-} from "./chunk-57ayxqnb.js";
+} from "./chunk-8fy8w7ds.js";
 import {
   HerdrLocalError,
   readHerdrPeer
-} from "./chunk-q5pgbwb3.js";
+} from "./chunk-e7jgpxkf.js";
 import {
   checkHerdrSignal,
   herdrDeadline,
   withHerdrSocket,
   exchangeHerdr,
   HerdrInstallation2
-} from "./chunk-863tk45b.js";
+} from "./chunk-41fny9qm.js";
 import {
   createHerdrReadonlyAdapter2
 } from "./chunk-zb641qa3.js";
 import {
   LuvusDispatchClaims2
-} from "./chunk-gbsbwssz.js";
+} from "./chunk-sf4ztxba.js";
+import {
+  LuvusAdapterError2,
+  ConnectorCapacityError
+} from "./chunk-pksaqt9a.js";
 
 // src/connector/herdr/wire.ts
 function identityOf(binding) {
@@ -273,4 +275,4 @@ function createHerdrRuntime2(installation, backend, claims, terminalExecution) {
 
 export { createHerdrWireAdapter, createHerdrRuntime2 };
 
-//# debugId=828EF1FDC5E8AF4B64756E2164756E21
+//# debugId=0A9E0EF4232D9B8364756E2164756E21

package/dist/src/{chunk-s3ydr65k.js → chunk-j59ac0xs.js}

@@ -1,8 +1,8 @@
 // @bun
 // src/mcp/version.ts
 var MCP_REVISION2 = "2025-11-25";
-var PRODUCT_VERSION2 = "0.6.0";
+var PRODUCT_VERSION2 = "0.6.1";
 
 export { MCP_REVISION2, PRODUCT_VERSION2 };
 
-//# debugId=F89FEF5D3124887164756E2164756E21
+//# debugId=D4F5A83CF09C923064756E2164756E21