@hasna/machines 0.0.23 → 0.0.24

package/dist/consumer.js

@@ -4312,29 +4312,78 @@ function getPackageVersion() {
 var MACHINES_CONSUMER_CONTRACT_VERSION = 1;
 var MACHINES_PACKAGE_NAME = "@hasna/machines";
 var MACHINES_CONSUMER_ENTRYPOINT = "@hasna/machines/consumer";
+var MACHINES_CONSUMER_SCHEMA_URI = "https://schemas.hasna.xyz/machines/consumer/v1/machines-consumer.schema.json";
+var MACHINES_CONSUMER_SCHEMA_ARTIFACT = "schemas/machines-consumer.schema.json";
+var DEFAULT_MACHINE_RESOLVER_TTL_MS = 24 * 60 * 60 * 1000;
 var MACHINES_CONSUMER_CAPABILITIES = {
   topology: true,
   compatibility: true,
   route_resolution: true,
   cli_json_fallback: true,
   workspace_path_mapping: true,
-  workspace_diagnostics: true
+  workspace_diagnostics: true,
+  schema_artifacts: true,
+  cacheability_metadata: true,
+  resolver_snapshots: true,
+  field_capability_descriptors: true
+};
+var MACHINES_CONSUMER_FIELD_CAPABILITIES = {
+  topology: {
+    machine_identity: true,
+    route_hints: true,
+    tailscale_status: true,
+    manifest_metadata: true
+  },
+  route: {
+    cacheability: true,
+    confidence: true,
+    resolver_evidence: true
+  },
+  workspace: {
+    cacheability: true,
+    path_mapping: true,
+    diagnostics: true,
+    repair_hints: true,
+    trust_auth: true
+  },
+  compatibility: {
+    commands: true,
+    packages: true,
+    workspaces: true
+  },
+  resolver_snapshot: {
+    cacheability: true,
+    redacted_provenance: true
+  }
 };
 var MACHINES_CONSUMER_CONTRACT = {
   schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
   package_name: MACHINES_PACKAGE_NAME,
   entrypoint: MACHINES_CONSUMER_ENTRYPOINT,
+  schema_uri: MACHINES_CONSUMER_SCHEMA_URI,
+  schema_artifact: MACHINES_CONSUMER_SCHEMA_ARTIFACT,
   capabilities: MACHINES_CONSUMER_CAPABILITIES,
-  envelopes: ["topology", "route", "workspace", "compatibility"],
+  field_capabilities: MACHINES_CONSUMER_FIELD_CAPABILITIES,
+  cacheability: {
+    default_ttl_ms: DEFAULT_MACHINE_RESOLVER_TTL_MS,
+    stale_requires_refresh: true
+  },
+  envelopes: ["topology", "route", "workspace", "compatibility", "resolver_snapshot"],
   stable_exports: [
     "MACHINES_CONSUMER_CONTRACT",
     "MACHINES_CONSUMER_CONTRACT_VERSION",
     "MACHINES_CONSUMER_CAPABILITIES",
+    "MACHINES_CONSUMER_FIELD_CAPABILITIES",
+    "MACHINES_CONSUMER_SCHEMA_BUNDLE",
+    "MACHINES_CONSUMER_SCHEMA_URI",
     "MACHINES_PACKAGE_NAME",
     "discoverMachineTopology",
     "getLocalMachineTopology",
     "resolveMachineRoute",
     "resolveMachineWorkspace",
+    "createMachineResolverSnapshot",
+    "getMachinesConsumerSchemaBundle",
+    "validateMachinesConsumerEnvelope",
     "checkMachineCompatibility",
     "resolveMachineCommand",
     "runMachineCommand",
@@ -4612,11 +4661,100 @@ function routeConfidence(input) {
     return "low";
   return "none";
 }
+function addMilliseconds(date, milliseconds) {
+  return new Date(date.getTime() + milliseconds).toISOString();
+}
+function routeAuthority(input) {
+  if (!input.machine)
+    return "unresolved";
+  if (input.matchedBy === "fallback")
+    return "fallback";
+  if (input.selectedHint?.kind === "local")
+    return "live_topology";
+  if (input.selectedHint?.kind === "tailscale" || input.machine.tailscale.online !== null)
+    return "live_topology";
+  if (input.machine.manifest_declared)
+    return "manifest";
+  return "open-machines";
+}
+function workspaceAuthority(paths) {
+  const sources = [paths.workspace_root.source, paths.project_root.source, paths.open_files_root.source];
+  if (sources.some((source) => source === "argument"))
+    return "argument";
+  if (sources.some((source) => source === "manifest_metadata"))
+    return "manifest_metadata";
+  if (sources.some((source) => source === "manifest"))
+    return "manifest";
+  if (sources.some((source) => source === "inferred"))
+    return "inferred";
+  if (sources.every((source) => source === "unresolved"))
+    return "unresolved";
+  return "open-machines";
+}
+function cacheability(input) {
+  const ttlMs = input.ttlMs === undefined ? DEFAULT_MACHINE_RESOLVER_TTL_MS : input.ttlMs;
+  const expiresAt = typeof ttlMs === "number" && ttlMs > 0 ? addMilliseconds(input.observedAt, ttlMs) : null;
+  const stale = expiresAt ? input.now.getTime() > new Date(expiresAt).getTime() : false;
+  const confidenceCacheable = input.confidence !== "none" && input.confidence !== "low";
+  const cacheable = input.ok && confidenceCacheable && !stale && input.authority !== "unresolved";
+  const reasons = [...input.reasons];
+  if (!input.ok)
+    reasons.push("resolver_not_ok");
+  if (!confidenceCacheable)
+    reasons.push(`low_confidence:${input.confidence}`);
+  if (stale)
+    reasons.push("stale");
+  if (input.authority === "unresolved")
+    reasons.push("unresolved_authority");
+  return {
+    observed_at: input.observedAt.toISOString(),
+    verified_at: input.ok ? input.now.toISOString() : null,
+    expires_at: expiresAt,
+    ttl_ms: typeof ttlMs === "number" && ttlMs > 0 ? ttlMs : null,
+    source_authority: input.authority,
+    confidence: input.confidence,
+    cacheable,
+    stale,
+    reasons: [...new Set(reasons)].sort()
+  };
+}
+function worstConfidence(values) {
+  const rank = {
+    exact: 0,
+    high: 1,
+    medium: 2,
+    low: 3,
+    none: 4
+  };
+  return [...values].sort((left, right) => rank[right] - rank[left])[0] ?? "none";
+}
+function mergeAuthorities(values) {
+  const filtered = values.filter((value) => value !== "unknown");
+  if (filtered.length === 0)
+    return "unknown";
+  const first = filtered[0];
+  return filtered.every((value) => value === first) ? first : "mixed";
+}
+function mergeCacheability(input) {
+  const confidence = worstConfidence(input.cacheabilities.map((entry) => entry.confidence));
+  const reasons = input.cacheabilities.flatMap((entry) => entry.reasons);
+  const ok = input.cacheabilities.every((entry) => entry.cacheable);
+  return cacheability({
+    ok,
+    observedAt: input.observedAt,
+    now: input.now,
+    ttlMs: input.ttlMs,
+    authority: mergeAuthorities(input.authorities),
+    confidence,
+    reasons
+  });
+}
 function resolveMachineRoute(machineId, options = {}) {
+  const now = options.now ?? new Date;
   const topology = options.topology ?? discoverMachineTopology(options);
   const warnings = [...topology.warnings];
   const { machine, matchedBy } = findRouteMachine(topology, machineId);
-  const generatedAt = (options.now ?? new Date).toISOString();
+  const generatedAt = now.toISOString();
   if (!machine) {
     warnings.push(`machine_not_found:${machineId}`);
     return {
@@ -4640,16 +4778,27 @@ function resolveMachineRoute(machineId, options = {}) {
         tailscale_online: null,
         selected_hint: null
       },
+      cacheability: cacheability({
+        ok: false,
+        observedAt: now,
+        now,
+        ttlMs: options.resolverTtlMs,
+        authority: "unresolved",
+        confidence: "none",
+        reasons: [`machine_not_found:${machineId}`]
+      }),
       warnings
     };
   }
   const selectedHint = selectRouteHint(machine.route_hints);
   const route = selectedHint?.kind ?? machine.ssh.route ?? "unknown";
   const local = route === "local" || machine.machine_id === topology.local_machine_id;
+  const confidence = routeConfidence({ machine, hint: selectedHint, matchedBy });
+  const ok = Boolean(selectedHint?.target);
   return {
     schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
     package: topology.package,
-    ok: Boolean(selectedHint?.target),
+    ok,
     machine_id: machine.machine_id,
     requested_machine_id: machineId,
     generated_at: generatedAt,
@@ -4657,7 +4806,7 @@ function resolveMachineRoute(machineId, options = {}) {
     source: route,
     target: selectedHint?.target ?? null,
     command_target: selectedHint?.target ?? null,
-    confidence: routeConfidence({ machine, hint: selectedHint, matchedBy }),
+    confidence,
     local,
     evidence: {
       topology: true,
@@ -4667,6 +4816,15 @@ function resolveMachineRoute(machineId, options = {}) {
       tailscale_online: machine.tailscale.online,
       selected_hint: selectedHint
     },
+    cacheability: cacheability({
+      ok,
+      observedAt: now,
+      now,
+      ttlMs: options.resolverTtlMs,
+      authority: routeAuthority({ machine, selectedHint, matchedBy }),
+      confidence,
+      reasons: selectedHint ? [] : ["route_target_unresolved"]
+    }),
     warnings
   };
 }
@@ -4963,10 +5121,11 @@ function metadataKeysForDiagnostics(metadata) {
   return Object.keys(metadata).filter((key) => !/(secret|token|key|password|credential)/i.test(key)).sort();
 }
 function resolveMachineWorkspace(options) {
+  const now = options.now ?? new Date;
   const topology = options.topology ?? discoverMachineTopology(options);
   const warnings = [...topology.warnings];
   const { machine, matchedBy } = findRouteMachine(topology, options.machineId);
-  const generatedAt = (options.now ?? new Date).toISOString();
+  const generatedAt = now.toISOString();
   const repoName = options.repoName ?? options.projectId;
   const openFilesRepoName = options.openFilesRepoName ?? "open-files";
   if (!machine) {
@@ -4993,6 +5152,15 @@ function resolveMachineWorkspace(options) {
         manifest_declared: null,
         metadata_keys: []
       },
+      cacheability: cacheability({
+        ok: false,
+        observedAt: now,
+        now,
+        ttlMs: options.resolverTtlMs,
+        authority: "unresolved",
+        confidence: "none",
+        reasons: [`machine_not_found:${options.machineId}`]
+      }),
       warnings
     };
     const diagnostics2 = workspaceDiagnostics({
@@ -5024,10 +5192,16 @@ function resolveMachineWorkspace(options) {
     warnings.push(`open_files_root_inferred:${options.projectId}`);
   if (!projectRootPath)
     warnings.push(`project_root_unresolved:${options.projectId}`);
+  const workspacePaths = {
+    workspace_root: { path: workspaceRootPath, source: workspaceRootSource },
+    project_root: { path: projectRootPath, source: projectRootSource },
+    open_files_root: { path: openFilesRootPath, source: openFilesRootSource }
+  };
+  const workspaceOk = Boolean(projectRootPath);
   const resolution = {
     schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
     package: topology.package,
-    ok: Boolean(projectRootPath),
+    ok: workspaceOk,
     requested_machine_id: options.machineId,
     machine_id: machine.machine_id,
     generated_at: generatedAt,
@@ -5042,11 +5216,7 @@ function resolveMachineWorkspace(options) {
       trust_status: trustStatus(machine),
       auth_status: authStatus(machine)
     },
-    paths: {
-      workspace_root: { path: workspaceRootPath, source: workspaceRootSource },
-      project_root: { path: projectRootPath, source: projectRootSource },
-      open_files_root: { path: openFilesRootPath, source: openFilesRootSource }
-    },
+    paths: workspacePaths,
     diagnostics: [],
     repair_hints: [],
     evidence: {
@@ -5055,6 +5225,15 @@ function resolveMachineWorkspace(options) {
       manifest_declared: machine.manifest_declared,
       metadata_keys: metadataKeysForDiagnostics(metadata)
     },
+    cacheability: cacheability({
+      ok: workspaceOk,
+      observedAt: now,
+      now,
+      ttlMs: options.resolverTtlMs,
+      authority: workspaceAuthority(workspacePaths),
+      confidence: workspaceOk ? "medium" : "none",
+      reasons: projectRootPath ? [] : [`project_root_unresolved:${options.projectId}`]
+    }),
     warnings
   };
   const diagnostics = workspaceDiagnostics({
@@ -5069,6 +5248,73 @@ function resolveMachineWorkspace(options) {
     repair_hints: diagnostics.repairHints
   };
 }
+function createMachineResolverSnapshot(options) {
+  const now = options.now ?? new Date;
+  const routeObservedAt = new Date(options.route.generated_at);
+  const workspaceObservedAt = options.workspace ? new Date(options.workspace.generated_at) : null;
+  const observedAt = new Date(Math.max(Number.isNaN(routeObservedAt.getTime()) ? 0 : routeObservedAt.getTime(), workspaceObservedAt && !Number.isNaN(workspaceObservedAt.getTime()) ? workspaceObservedAt.getTime() : 0));
+  const cacheabilities = [options.route.cacheability, options.workspace?.cacheability].filter((entry) => Boolean(entry));
+  const authorities = cacheabilities.map((entry) => entry.source_authority);
+  const warnings = [...new Set([
+    ...options.route.warnings,
+    ...options.workspace?.warnings ?? [],
+    ...cacheabilities.flatMap((entry) => entry.reasons)
+  ])].sort();
+  return {
+    schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
+    package: options.route.package,
+    generated_at: now.toISOString(),
+    requested_machine_id: options.route.requested_machine_id,
+    machine_id: options.route.machine_id ?? options.workspace?.machine_id ?? null,
+    route: {
+      ok: options.route.ok,
+      source: options.route.source,
+      route: options.route.route,
+      target: options.route.target,
+      command_target: options.route.command_target,
+      confidence: options.route.confidence,
+      local: options.route.local,
+      cacheability: options.route.cacheability
+    },
+    workspace: options.workspace ? {
+      ok: options.workspace.ok,
+      project: options.workspace.project,
+      machine: options.workspace.machine,
+      paths: options.workspace.paths,
+      diagnostics: options.workspace.diagnostics,
+      repair_hints: options.workspace.repair_hints,
+      cacheability: options.workspace.cacheability
+    } : null,
+    cacheability: mergeCacheability({
+      observedAt: observedAt.getTime() > 0 ? observedAt : now,
+      now,
+      ttlMs: options.resolverTtlMs,
+      authorities,
+      cacheabilities
+    }),
+    warnings,
+    provenance: {
+      route: {
+        schema_version: options.route.schema_version,
+        generated_at: options.route.generated_at,
+        evidence: {
+          matched_by: options.route.evidence.matched_by,
+          manifest_declared: options.route.evidence.manifest_declared,
+          heartbeat_status: options.route.evidence.heartbeat_status,
+          tailscale_online: options.route.evidence.tailscale_online,
+          selected_hint_kind: options.route.evidence.selected_hint?.kind ?? null
+        }
+      },
+      workspace: options.workspace ? {
+        schema_version: options.workspace.schema_version,
+        generated_at: options.workspace.generated_at,
+        metadata_keys: options.workspace.evidence.metadata_keys,
+        matched_by: options.workspace.evidence.matched_by,
+        manifest_declared: options.workspace.evidence.manifest_declared
+      } : null
+    }
+  };
+}
 function getLocalMachineTopology(options = {}) {
   const topology = discoverMachineTopology(options);
   return topology.machines.find((machine) => machine.machine_id === topology.local_machine_id) ?? {
@@ -5088,6 +5334,237 @@ function getLocalMachineTopology(options = {}) {
     metadata: {}
   };
 }
+// src/consumer-schema.ts
+var MACHINES_CONSUMER_SCHEMA_BUNDLE = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: MACHINES_CONSUMER_SCHEMA_URI,
+  title: "@hasna/machines consumer contract schema bundle",
+  type: "object",
+  $defs: {
+    cacheability: {
+      type: "object",
+      required: ["observed_at", "verified_at", "expires_at", "ttl_ms", "source_authority", "confidence", "cacheable", "stale", "reasons"],
+      properties: {
+        observed_at: { type: "string", format: "date-time" },
+        verified_at: { type: ["string", "null"], format: "date-time" },
+        expires_at: { type: ["string", "null"], format: "date-time" },
+        ttl_ms: { type: ["number", "null"] },
+        source_authority: { enum: ["open-machines", "manifest", "manifest_metadata", "live_topology", "argument", "inferred", "fallback", "unresolved", "mixed", "unknown"] },
+        confidence: { enum: ["exact", "high", "medium", "low", "none"] },
+        cacheable: { type: "boolean" },
+        stale: { type: "boolean" },
+        reasons: { type: "array", items: { type: "string" } }
+      }
+    },
+    contract: {
+      type: "object",
+      required: ["schema_version", "package_name", "entrypoint", "schema_uri", "schema_artifact", "capabilities", "field_capabilities", "cacheability", "envelopes", "stable_exports"],
+      properties: {
+        schema_version: { const: MACHINES_CONSUMER_CONTRACT_VERSION },
+        package_name: { const: "@hasna/machines" },
+        entrypoint: { const: "@hasna/machines/consumer" },
+        schema_uri: { const: MACHINES_CONSUMER_SCHEMA_URI },
+        schema_artifact: { const: "schemas/machines-consumer.schema.json" },
+        capabilities: { type: "object" },
+        field_capabilities: { type: "object" },
+        cacheability: { type: "object" },
+        envelopes: { type: "array", items: { enum: ["topology", "route", "workspace", "compatibility", "resolver_snapshot"] } },
+        stable_exports: { type: "array", items: { type: "string" } }
+      }
+    },
+    topology: {
+      type: "object",
+      required: ["schema_version", "package", "capabilities", "generated_at", "local_machine_id", "machines", "warnings"],
+      properties: {
+        schema_version: { const: MACHINES_CONSUMER_CONTRACT_VERSION },
+        package: { type: "object" },
+        capabilities: { type: "object" },
+        generated_at: { type: "string", format: "date-time" },
+        local_machine_id: { type: "string" },
+        machines: { type: "array" },
+        warnings: { type: "array", items: { type: "string" } }
+      }
+    },
+    route: {
+      type: "object",
+      required: ["schema_version", "package", "ok", "machine_id", "requested_machine_id", "generated_at", "route", "source", "target", "command_target", "confidence", "local", "evidence", "cacheability", "warnings"],
+      properties: {
+        schema_version: { const: MACHINES_CONSUMER_CONTRACT_VERSION },
+        package: { type: "object" },
+        ok: { type: "boolean" },
+        machine_id: { type: ["string", "null"] },
+        requested_machine_id: { type: "string" },
+        generated_at: { type: "string", format: "date-time" },
+        route: { enum: ["local", "lan", "tailscale", "ssh", "unknown"] },
+        source: { enum: ["local", "lan", "tailscale", "ssh", "unknown"] },
+        target: { type: ["string", "null"] },
+        command_target: { type: ["string", "null"] },
+        confidence: { enum: ["exact", "high", "medium", "low", "none"] },
+        local: { type: "boolean" },
+        evidence: { type: "object" },
+        cacheability: { $ref: "#/$defs/cacheability" },
+        warnings: { type: "array", items: { type: "string" } }
+      }
+    },
+    workspace: {
+      type: "object",
+      required: ["schema_version", "package", "ok", "requested_machine_id", "machine_id", "generated_at", "project", "machine", "paths", "diagnostics", "repair_hints", "evidence", "cacheability", "warnings"],
+      properties: {
+        schema_version: { const: MACHINES_CONSUMER_CONTRACT_VERSION },
+        package: { type: "object" },
+        ok: { type: "boolean" },
+        requested_machine_id: { type: "string" },
+        machine_id: { type: ["string", "null"] },
+        generated_at: { type: "string", format: "date-time" },
+        project: { type: "object" },
+        machine: {
+          type: "object",
+          required: ["current", "primary", "trust_status", "auth_status"],
+          properties: {
+            current: { type: "boolean" },
+            primary: { type: "boolean" },
+            trust_status: { enum: ["trusted", "untrusted", "unknown"] },
+            auth_status: { enum: ["authenticated", "unauthenticated", "unknown"] }
+          }
+        },
+        paths: { type: "object" },
+        diagnostics: { type: "array" },
+        repair_hints: { type: "array" },
+        evidence: { type: "object" },
+        cacheability: { $ref: "#/$defs/cacheability" },
+        warnings: { type: "array", items: { type: "string" } }
+      }
+    },
+    compatibility: {
+      type: "object",
+      required: ["schema_version", "package", "capabilities", "ok", "machine_id", "source", "generated_at", "checks", "summary"],
+      properties: {
+        schema_version: { const: MACHINES_CONSUMER_CONTRACT_VERSION },
+        package: { type: "object" },
+        capabilities: { type: "object" },
+        ok: { type: "boolean" },
+        machine_id: { type: "string" },
+        source: { type: "string" },
+        generated_at: { type: "string", format: "date-time" },
+        checks: { type: "array" },
+        summary: { type: "object" }
+      }
+    },
+    resolver_snapshot: {
+      type: "object",
+      required: ["schema_version", "package", "generated_at", "requested_machine_id", "machine_id", "route", "workspace", "cacheability", "warnings", "provenance"],
+      properties: {
+        schema_version: { const: MACHINES_CONSUMER_CONTRACT_VERSION },
+        package: { type: "object" },
+        generated_at: { type: "string", format: "date-time" },
+        requested_machine_id: { type: "string" },
+        machine_id: { type: ["string", "null"] },
+        route: { type: "object" },
+        workspace: { type: ["object", "null"] },
+        cacheability: { $ref: "#/$defs/cacheability" },
+        warnings: { type: "array", items: { type: "string" } },
+        provenance: { type: "object" }
+      }
+    }
+  }
+};
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function hasString(value, key) {
+  return typeof value[key] === "string" && value[key].length > 0;
+}
+function hasObject(value, key) {
+  return isRecord2(value[key]);
+}
+function hasArray(value, key) {
+  return Array.isArray(value[key]);
+}
+function hasCacheability(value, key = "cacheability") {
+  const cache = value[key];
+  return isRecord2(cache) && hasString(cache, "observed_at") && typeof cache.cacheable === "boolean" && typeof cache.stale === "boolean" && hasArray(cache, "reasons");
+}
+function requireFields(value, fields, errors2) {
+  for (const field of fields) {
+    if (!(field in value))
+      errors2.push(`missing:${field}`);
+  }
+}
+function getMachinesConsumerSchemaBundle() {
+  return JSON.parse(JSON.stringify(MACHINES_CONSUMER_SCHEMA_BUNDLE));
+}
+function validateMachinesConsumerEnvelope(envelope, value) {
+  const errors2 = [];
+  if (!isRecord2(value)) {
+    return { ok: false, envelope, schema_id: MACHINES_CONSUMER_SCHEMA_URI, errors: ["not_object"] };
+  }
+  if (value.schema_version !== MACHINES_CONSUMER_CONTRACT_VERSION)
+    errors2.push(`schema_version:${String(value.schema_version)}`);
+  if (envelope === "contract") {
+    requireFields(value, ["package_name", "entrypoint", "schema_uri", "schema_artifact", "capabilities", "field_capabilities", "cacheability", "envelopes", "stable_exports"], errors2);
+    if (value.package_name !== "@hasna/machines")
+      errors2.push("package_name");
+    if (value.entrypoint !== "@hasna/machines/consumer")
+      errors2.push("entrypoint");
+    if (!hasObject(value, "capabilities"))
+      errors2.push("capabilities");
+    if (!hasObject(value, "field_capabilities"))
+      errors2.push("field_capabilities");
+    if (!hasArray(value, "envelopes"))
+      errors2.push("envelopes");
+    if (!hasArray(value, "stable_exports"))
+      errors2.push("stable_exports");
+  } else if (envelope === "topology") {
+    requireFields(value, ["package", "capabilities", "generated_at", "local_machine_id", "machines", "warnings"], errors2);
+    if (!hasArray(value, "machines"))
+      errors2.push("machines");
+    if (!hasArray(value, "warnings"))
+      errors2.push("warnings");
+  } else if (envelope === "route") {
+    requireFields(value, ["package", "ok", "machine_id", "requested_machine_id", "generated_at", "route", "source", "target", "command_target", "confidence", "local", "evidence", "cacheability", "warnings"], errors2);
+    if (typeof value.ok !== "boolean")
+      errors2.push("ok");
+    if (!hasObject(value, "evidence"))
+      errors2.push("evidence");
+    if (!hasCacheability(value))
+      errors2.push("cacheability");
+    if (!hasArray(value, "warnings"))
+      errors2.push("warnings");
+  } else if (envelope === "workspace") {
+    requireFields(value, ["package", "ok", "requested_machine_id", "machine_id", "generated_at", "project", "machine", "paths", "diagnostics", "repair_hints", "evidence", "cacheability", "warnings"], errors2);
+    if (typeof value.ok !== "boolean")
+      errors2.push("ok");
+    if (!hasObject(value, "machine"))
+      errors2.push("machine");
+    if (!hasObject(value, "paths"))
+      errors2.push("paths");
+    if (!hasArray(value, "diagnostics"))
+      errors2.push("diagnostics");
+    if (!hasArray(value, "repair_hints"))
+      errors2.push("repair_hints");
+    if (!hasCacheability(value))
+      errors2.push("cacheability");
+  } else if (envelope === "compatibility") {
+    requireFields(value, ["package", "capabilities", "ok", "machine_id", "source", "generated_at", "checks", "summary"], errors2);
+    if (typeof value.ok !== "boolean")
+      errors2.push("ok");
+    if (!hasArray(value, "checks"))
+      errors2.push("checks");
+    if (!hasObject(value, "summary"))
+      errors2.push("summary");
+  } else if (envelope === "resolver_snapshot") {
+    requireFields(value, ["package", "generated_at", "requested_machine_id", "machine_id", "route", "workspace", "cacheability", "warnings", "provenance"], errors2);
+    if (!hasObject(value, "route"))
+      errors2.push("route");
+    if (!hasCacheability(value))
+      errors2.push("cacheability");
+    if (!hasArray(value, "warnings"))
+      errors2.push("warnings");
+    if (!hasObject(value, "provenance"))
+      errors2.push("provenance");
+  }
+  return { ok: errors2.length === 0, envelope, schema_id: MACHINES_CONSUMER_SCHEMA_URI, errors: errors2 };
+}
 // src/remote.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { hostname as hostname4 } from "os";
@@ -5397,20 +5874,28 @@ function checkMachineCompatibility(options = {}) {
   };
 }
 export {
+  validateMachinesConsumerEnvelope,
   runMachineCommand,
   resolveSshTarget,
   resolveMachineWorkspace,
   resolveMachineRoute,
   resolveMachineCommand,
   getPackageVersion,
+  getMachinesConsumerSchemaBundle,
   getMachinesConsumerCapabilities,
   getLocalMachineTopology,
   discoverMachineTopology,
+  createMachineResolverSnapshot,
   checkMachineCompatibility,
   buildSshCommand,
   MACHINES_PACKAGE_NAME,
+  MACHINES_CONSUMER_SCHEMA_URI,
+  MACHINES_CONSUMER_SCHEMA_BUNDLE,
+  MACHINES_CONSUMER_SCHEMA_ARTIFACT,
+  MACHINES_CONSUMER_FIELD_CAPABILITIES,
   MACHINES_CONSUMER_ENTRYPOINT,
   MACHINES_CONSUMER_CONTRACT_VERSION,
   MACHINES_CONSUMER_CONTRACT,
-  MACHINES_CONSUMER_CAPABILITIES
+  MACHINES_CONSUMER_CAPABILITIES,
+  DEFAULT_MACHINE_RESOLVER_TTL_MS
 };