@forgezero/vault 0.1.1 → 0.1.3

package/README.md

@@ -2,10 +2,11 @@
 
 **Read your secrets at runtime instead of shipping them in a file.**
 
-The client discovers its own credential and, for an API key, asks a directory
-which node to talk to. There is no endpoint to configure. The same code runs on
-a laptop and in production: outside managed compute the key is a local signing
-seed; on managed compute there is no remote credential in the application.
+The client discovers its own credential and uses one stable API origin. Node
+routing and failover stay behind that edge contract; the SDK never discovers or
+stores a node hostname. The same code runs on a laptop and in production:
+outside managed compute the key is a local signing seed; on managed compute
+there is no remote credential in the application.
 
 This one talks to a ForgeZero vault, so it needs an account. The other three
 packages do not.
@@ -56,8 +57,10 @@ An entry can declare fields the tenant never holds. Two custody modes:
   exists in plaintext only inside a signing call.
 - **supplied** — you generate it, the vault seals it.
 
-Either way there is no call that returns a private key. Custody operations stay
-on the authenticated platform surface; the application credential is read-only.
+Either way there is no call that returns a private key. Derivation and signing
+stay inside explicit trusted platform workflows; the general application
+credential remains a read-only secret client and is not a transaction-signing
+oracle.
 
 ## Subpaths
 

package/dist/index.d.ts

@@ -16,12 +16,13 @@
  * places, and the stronger posture is the one requiring less configuration
  * rather than more.
  *
- * ## Node assignment
+ * ## Stable API origin
  *
- * A directory answers which node to use; the client then talks to it directly
- * for a short window. Reassignment includes 530 — a node whose TUNNEL is down
- * returns Cloudflare 1033, not an application status, so a retry list of only
- * 5xx misses it entirely.
+ * External clients always call one API origin. Node selection and failover are
+ * edge responsibilities; exposing node hostnames here would couple every SDK
+ * to platform topology and can route a tenant to a process that does not hold
+ * its realm seed. Managed applications continue to use the local agent socket
+ * and make no remote request at all.
  *
  * This package must not import `@forgezero/providers` either. `vaultCredentials`
  * returns the shape structurally, because a dependency edge in either direction
@@ -104,23 +105,9 @@ export type AgentResponse = {
     };
 };
 export type AgentTransport = (socketPath: string, request: AgentRequest) => Promise<AgentResponse>;
-export interface Assignment {
-    node: string;
-    ttl: number;
-    expiresAt: number;
-}
-/**
- * Statuses meaning "ask for a different node", not "this failed".
- *
- * 530 is the one people miss: a node whose tunnel is down never reaches the
- * application, so Cloudflare answers 1033 with 530.
- */
-export declare const REASSIGN_ON: Set<number>;
 export interface VaultOptions {
-    /** Directory endpoint. Unauthenticated — a node hostname is not a secret. */
-    assignUrl?: string;
-    /** Override only for a private ForgeZero installation with its own node domain. */
-    nodeAllowed?: (hostname: string) => boolean;
+    /** Stable public API origin. Node topology is never exposed to the client. */
+    apiUrl?: string;
     requestTimeoutMs?: number;
     project?: string;
     environment?: string;
@@ -129,7 +116,6 @@ export interface VaultOptions {
     agentTransport?: AgentTransport;
     credential?: Credential;
     discovery?: DiscoveryEnvironment;
-    now?: () => number;
 }
 export interface EntryMeta {
     name: string;
@@ -142,27 +128,18 @@ export interface Change {
     name: string;
     version: number;
 }
-export declare const DEFAULT_ASSIGN_URL = "https://assign.forgezero.net/v1/assign";
+export declare const DEFAULT_API_URL = "https://api.forgezero.net";
 export declare const DEFAULT_REQUEST_TIMEOUT_MS = 15000;
-/** A compromised directory must not turn a signed secret read into an open relay. */
-export declare const isForgeZeroNode: (hostname: string) => boolean;
 export declare class ForgeZero {
     readonly credential: Credential;
-    private assignment;
-    private readonly assignUrl;
+    private readonly apiUrl;
     private readonly doFetch;
-    private readonly now;
     private readonly signer?;
     private readonly agentTransport;
-    private readonly nodeAllowed;
     private readonly requestTimeoutMs;
     private readonly project;
     private readonly environment;
     constructor(options?: VaultOptions);
-    /** The node to talk to, asking the directory only when the lease expired. */
-    node(): Promise<string>;
-    /** Drop the lease so the next call asks the directory again. */
-    reassign(): void;
     private scope;
     private request;
     private managedRequest;
@@ -179,41 +156,35 @@ export declare class ForgeZero {
      */
     getAll(): Promise<Record<string, string>>;
     /**
-     * The PUBLIC half of a value ForgeZero derived from the realm master seed.
+     * Custody derivation is intentionally not a general application-key action.
      *
-     * There is no call that returns the private half, and that is the whole
-     * design rather than an omission. A tenant that can fetch a signing key holds
-     * the full risk of holding one: it lands in their backups, their logs, their
-     * heap dumps and their environment. Here they declare which chain they
-     * activated, the platform derives from the seed, and an ADDRESS is the only
-     * thing that crosses back.
+     * Kept as a typed refusal for compatibility with the early package preview,
+     * which exposed this method before a secured custody workflow existed. A
+     * compromised secret-reading process must not silently become a transaction
+     * signer merely because both operations happen to involve the vault.
      *
-     * Deterministic, so losing the row loses the metadata and not the money —
-     * re-declaring the same chain and index derives the same address.
+     * @deprecated Use an explicit platform custody workflow with its own policy,
+     * approval and audit contract.
      */
     derived(name: string, field: string): Promise<{
         address: string;
         path: string;
     }>;
     /**
-     * Sign a digest with a derived key, without the key ever leaving.
-     *
-     * The tenant builds the unsigned transaction, hashes it, and sends the
-     * digest. What comes back is a signature. A compromised tenant process can
-     * ASK for signatures — which is bounded, logged and revocable — and cannot
-     * take the key, which would be none of those things.
-     *
-     * A digest rather than a transaction on purpose: the platform is not a
-     * transaction builder for every chain a tenant might use, and pretending
-     * otherwise would make ForgeZero the thing that has to understand every
-     * chain format before a tenant can support one.
+     * @deprecated A general application vault credential is not a signing oracle.
      */
     sign(name: string, field: string, digest: string): Promise<{
         signature: string;
         recovery?: number;
         path: string;
     }>;
-    /** Schemas the platform holds, for a managed source. */
+    /**
+     * List schemas represented by reserved vault entries.
+     *
+     * Kept for compatibility; `managedSchemas(vault).list()` is the higher-level
+     * interface. It deliberately uses `list` and `get`, so both the local agent
+     * and signed HTTPS transports follow the same contract.
+     */
     schemas(): Promise<readonly {
         name: string;
         version: number;
@@ -296,4 +267,4 @@ export declare function systemdCredentials(options?: SystemdCredentialOptions):
     readonly name: 'systemd';
     get(reference: string, field: string): Promise<string>;
 };
-export declare const VERSION = "0.1.1";
+export declare const VERSION = "0.1.2";

package/dist/index.js

@@ -110,32 +110,37 @@ var requestAgent = (socketPath, request) => new Promise((resolveRequest, reject)
   });
   socket.on("error", (cause) => reject(new VaultError("AGENT_UNAVAILABLE", cause.message)));
 });
-var REASSIGN_ON = new Set([410, 421, 502, 503, 504, 530]);
-var DEFAULT_ASSIGN_URL = "https://assign.forgezero.net/v1/assign";
+var DEFAULT_API_URL = "https://api.forgezero.net";
 var DEFAULT_REQUEST_TIMEOUT_MS = 15000;
-var isForgeZeroNode = (hostname) => /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+forgezero\.net$/.test(hostname);
+function apiOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new VaultError("API_URL_INVALID", "apiUrl must be an absolute HTTPS origin.");
+  }
+  const local = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+  if (url.protocol !== "https:" && !(local && url.protocol === "http:") || url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "")
+    throw new VaultError("API_URL_INVALID", "apiUrl must be an HTTPS origin without credentials, path, query or fragment.");
+  return url;
+}
 
 class ForgeZero {
   credential;
-  assignment;
-  assignUrl;
+  apiUrl;
   doFetch;
-  now;
   signer;
   agentTransport;
-  nodeAllowed;
   requestTimeoutMs;
   project;
   environment;
   constructor(options = {}) {
     const credential = options.credential ?? discover(options.discovery);
     this.credential = credential.mode === "managed" && !credential.socketPath ? { ...credential, socketPath: DEFAULT_SOCKET } : credential;
-    this.assignUrl = options.assignUrl ?? DEFAULT_ASSIGN_URL;
+    this.apiUrl = apiOrigin(options.apiUrl ?? DEFAULT_API_URL);
     this.doFetch = options.fetch ?? globalThis.fetch;
-    this.now = options.now ?? Date.now;
     this.signer = options.signer ?? (this.credential.mode === "external" ? signerFromApiKey(this.credential.apiKey) : undefined);
     this.agentTransport = options.agentTransport ?? requestAgent;
-    this.nodeAllowed = options.nodeAllowed ?? isForgeZeroNode;
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     if (!Number.isFinite(this.requestTimeoutMs) || this.requestTimeoutMs < 100 || this.requestTimeoutMs > 120000) {
       throw new VaultError("INVALID_TIMEOUT", "requestTimeoutMs must be between 100 and 120000 milliseconds.");
@@ -143,45 +148,14 @@ class ForgeZero {
     this.project = options.project ?? "default";
     this.environment = options.environment ?? "production";
   }
-  async node() {
-    const now = this.now();
-    if (this.assignment && this.assignment.expiresAt > now)
-      return this.assignment.node;
-    const assignmentUrl = new URL(this.assignUrl);
-    if (this.signer?.keyId && !assignmentUrl.searchParams.has("client")) {
-      assignmentUrl.searchParams.set("client", this.signer.keyId);
-    }
-    const response = await this.doFetch(assignmentUrl, {
-      method: "GET",
-      headers: { accept: "application/json" },
-      signal: AbortSignal.timeout(this.requestTimeoutMs)
-    });
-    if (!response.ok)
-      throw new VaultError("NO_NODE", "No vault node is available right now.");
-    const payload = await response.json().catch(() => null);
-    const hostname = typeof payload?.node === "string" ? payload.node : payload?.node && typeof payload.node === "object" && ("hostname" in payload.node) ? payload.node.hostname : undefined;
-    if (typeof hostname !== "string" || !this.nodeAllowed(hostname)) {
-      throw new VaultError("UNTRUSTED_NODE", "The directory returned an untrusted vault node hostname.");
-    }
-    const ttl = payload?.ttl ?? 60;
-    if (typeof ttl !== "number" || !Number.isFinite(ttl) || ttl < 1 || ttl > 300) {
-      throw new VaultError("INVALID_ASSIGNMENT", "The directory returned an invalid vault-node lease.");
-    }
-    this.assignment = { node: hostname, ttl, expiresAt: now + ttl * 1000 };
-    return hostname;
-  }
-  reassign() {
-    this.assignment = undefined;
-  }
   scope() {
     return `${encodeURIComponent(this.project)}/${encodeURIComponent(this.environment)}`;
   }
-  async request(path, init = {}, retried = false) {
+  async request(path, init = {}) {
     if (this.credential.mode === "managed")
       return this.managedRequest(path, init);
-    const node = await this.node();
     const body = typeof init.body === "string" ? init.body : "";
-    const target = new URL(path, "https://vault.invalid");
+    const target = new URL(path, this.apiUrl);
     const headers = {
       "content-type": "application/json",
       ...init.headers
@@ -195,15 +169,11 @@ class ForgeZero {
         body
       });
     }
-    const response = await this.doFetch(`https://${node}${path}`, {
+    const response = await this.doFetch(target, {
       ...init,
       headers,
       signal: init.signal ?? AbortSignal.timeout(this.requestTimeoutMs)
     });
-    if (REASSIGN_ON.has(response.status) && !retried) {
-      this.reassign();
-      return this.request(path, init, true);
-    }
     const payload = await response.json().catch(() => {
       return;
     });
@@ -284,14 +254,28 @@ class ForgeZero {
     return result.values;
   }
   async derived(name, field) {
-    return this.request(`/v1/entries/${encodeURIComponent(name)}/derived/${encodeURIComponent(field)}${this.scope()}`);
+    throw new VaultError("CUSTODY_WORKFLOW_REQUIRED", "Derived custody keys require an explicit platform custody workflow; an application vault credential cannot request them.");
   }
   async sign(name, field, digest) {
-    return this.request(`/v1/entries/${encodeURIComponent(name)}/sign/${encodeURIComponent(field)}${this.scope()}`, { method: "POST", body: JSON.stringify({ digest }) });
+    throw new VaultError("CUSTODY_WORKFLOW_REQUIRED", "Signing requires an explicit platform custody workflow with its own policy, approval and audit contract.");
   }
   async schemas() {
-    const payload = await this.request(`/v1/schemas${this.scope()}`);
-    return payload.schemas ?? [];
+    const entries = await this.list();
+    const names = entries.map((entry) => entry.name).filter((name) => name.startsWith("__schema__")).map((name) => name.slice("__schema__".length)).filter(Boolean);
+    return Promise.all(names.map(async (name) => {
+      let value;
+      try {
+        value = JSON.parse(await this.get(`__schema__${name}`));
+      } catch (cause) {
+        if (cause instanceof VaultError)
+          throw cause;
+        throw new VaultError("SCHEMA_MALFORMED", `The schema for ${name} is not JSON.`);
+      }
+      if (!Number.isInteger(value.version) || Number(value.version) < 1) {
+        throw new VaultError("SCHEMA_MALFORMED", `The schema for ${name} has no valid version.`);
+      }
+      return { name, version: Number(value.version) };
+    }));
   }
   async list() {
     const result = await this.request(`/v1/vault/${this.scope()}/list`);
@@ -362,20 +346,18 @@ function systemdCredentials(options = {}) {
     }
   };
 }
-var VERSION = "0.1.1";
+var VERSION = "0.1.2";
 export {
   vaultCredentials,
   systemdCredentials,
   signerFromApiKey,
-  isForgeZeroNode,
   discover,
   directCredentials,
   createVault,
   VaultError,
   VERSION,
-  REASSIGN_ON,
   ForgeZero,
   DEFAULT_SOCKET,
   DEFAULT_REQUEST_TIMEOUT_MS,
-  DEFAULT_ASSIGN_URL
+  DEFAULT_API_URL
 };

package/dist/providers.js

@@ -110,32 +110,37 @@ var requestAgent = (socketPath, request) => new Promise((resolveRequest, reject)
   });
   socket.on("error", (cause) => reject(new VaultError("AGENT_UNAVAILABLE", cause.message)));
 });
-var REASSIGN_ON = new Set([410, 421, 502, 503, 504, 530]);
-var DEFAULT_ASSIGN_URL = "https://assign.forgezero.net/v1/assign";
+var DEFAULT_API_URL = "https://api.forgezero.net";
 var DEFAULT_REQUEST_TIMEOUT_MS = 15000;
-var isForgeZeroNode = (hostname) => /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+forgezero\.net$/.test(hostname);
+function apiOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new VaultError("API_URL_INVALID", "apiUrl must be an absolute HTTPS origin.");
+  }
+  const local = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+  if (url.protocol !== "https:" && !(local && url.protocol === "http:") || url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "")
+    throw new VaultError("API_URL_INVALID", "apiUrl must be an HTTPS origin without credentials, path, query or fragment.");
+  return url;
+}
 
 class ForgeZero {
   credential;
-  assignment;
-  assignUrl;
+  apiUrl;
   doFetch;
-  now;
   signer;
   agentTransport;
-  nodeAllowed;
   requestTimeoutMs;
   project;
   environment;
   constructor(options = {}) {
     const credential = options.credential ?? discover(options.discovery);
     this.credential = credential.mode === "managed" && !credential.socketPath ? { ...credential, socketPath: DEFAULT_SOCKET } : credential;
-    this.assignUrl = options.assignUrl ?? DEFAULT_ASSIGN_URL;
+    this.apiUrl = apiOrigin(options.apiUrl ?? DEFAULT_API_URL);
     this.doFetch = options.fetch ?? globalThis.fetch;
-    this.now = options.now ?? Date.now;
     this.signer = options.signer ?? (this.credential.mode === "external" ? signerFromApiKey(this.credential.apiKey) : undefined);
     this.agentTransport = options.agentTransport ?? requestAgent;
-    this.nodeAllowed = options.nodeAllowed ?? isForgeZeroNode;
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     if (!Number.isFinite(this.requestTimeoutMs) || this.requestTimeoutMs < 100 || this.requestTimeoutMs > 120000) {
       throw new VaultError("INVALID_TIMEOUT", "requestTimeoutMs must be between 100 and 120000 milliseconds.");
@@ -143,45 +148,14 @@ class ForgeZero {
     this.project = options.project ?? "default";
     this.environment = options.environment ?? "production";
   }
-  async node() {
-    const now = this.now();
-    if (this.assignment && this.assignment.expiresAt > now)
-      return this.assignment.node;
-    const assignmentUrl = new URL(this.assignUrl);
-    if (this.signer?.keyId && !assignmentUrl.searchParams.has("client")) {
-      assignmentUrl.searchParams.set("client", this.signer.keyId);
-    }
-    const response = await this.doFetch(assignmentUrl, {
-      method: "GET",
-      headers: { accept: "application/json" },
-      signal: AbortSignal.timeout(this.requestTimeoutMs)
-    });
-    if (!response.ok)
-      throw new VaultError("NO_NODE", "No vault node is available right now.");
-    const payload = await response.json().catch(() => null);
-    const hostname = typeof payload?.node === "string" ? payload.node : payload?.node && typeof payload.node === "object" && ("hostname" in payload.node) ? payload.node.hostname : undefined;
-    if (typeof hostname !== "string" || !this.nodeAllowed(hostname)) {
-      throw new VaultError("UNTRUSTED_NODE", "The directory returned an untrusted vault node hostname.");
-    }
-    const ttl = payload?.ttl ?? 60;
-    if (typeof ttl !== "number" || !Number.isFinite(ttl) || ttl < 1 || ttl > 300) {
-      throw new VaultError("INVALID_ASSIGNMENT", "The directory returned an invalid vault-node lease.");
-    }
-    this.assignment = { node: hostname, ttl, expiresAt: now + ttl * 1000 };
-    return hostname;
-  }
-  reassign() {
-    this.assignment = undefined;
-  }
   scope() {
     return `${encodeURIComponent(this.project)}/${encodeURIComponent(this.environment)}`;
   }
-  async request(path, init = {}, retried = false) {
+  async request(path, init = {}) {
     if (this.credential.mode === "managed")
       return this.managedRequest(path, init);
-    const node = await this.node();
     const body = typeof init.body === "string" ? init.body : "";
-    const target = new URL(path, "https://vault.invalid");
+    const target = new URL(path, this.apiUrl);
     const headers = {
       "content-type": "application/json",
       ...init.headers
@@ -195,15 +169,11 @@ class ForgeZero {
         body
       });
     }
-    const response = await this.doFetch(`https://${node}${path}`, {
+    const response = await this.doFetch(target, {
       ...init,
       headers,
       signal: init.signal ?? AbortSignal.timeout(this.requestTimeoutMs)
     });
-    if (REASSIGN_ON.has(response.status) && !retried) {
-      this.reassign();
-      return this.request(path, init, true);
-    }
     const payload = await response.json().catch(() => {
       return;
     });
@@ -284,14 +254,28 @@ class ForgeZero {
     return result.values;
   }
   async derived(name, field) {
-    return this.request(`/v1/entries/${encodeURIComponent(name)}/derived/${encodeURIComponent(field)}${this.scope()}`);
+    throw new VaultError("CUSTODY_WORKFLOW_REQUIRED", "Derived custody keys require an explicit platform custody workflow; an application vault credential cannot request them.");
   }
   async sign(name, field, digest) {
-    return this.request(`/v1/entries/${encodeURIComponent(name)}/sign/${encodeURIComponent(field)}${this.scope()}`, { method: "POST", body: JSON.stringify({ digest }) });
+    throw new VaultError("CUSTODY_WORKFLOW_REQUIRED", "Signing requires an explicit platform custody workflow with its own policy, approval and audit contract.");
   }
   async schemas() {
-    const payload = await this.request(`/v1/schemas${this.scope()}`);
-    return payload.schemas ?? [];
+    const entries = await this.list();
+    const names = entries.map((entry) => entry.name).filter((name) => name.startsWith("__schema__")).map((name) => name.slice("__schema__".length)).filter(Boolean);
+    return Promise.all(names.map(async (name) => {
+      let value;
+      try {
+        value = JSON.parse(await this.get(`__schema__${name}`));
+      } catch (cause) {
+        if (cause instanceof VaultError)
+          throw cause;
+        throw new VaultError("SCHEMA_MALFORMED", `The schema for ${name} is not JSON.`);
+      }
+      if (!Number.isInteger(value.version) || Number(value.version) < 1) {
+        throw new VaultError("SCHEMA_MALFORMED", `The schema for ${name} has no valid version.`);
+      }
+      return { name, version: Number(value.version) };
+    }));
   }
   async list() {
     const result = await this.request(`/v1/vault/${this.scope()}/list`);
@@ -362,7 +346,7 @@ function systemdCredentials(options = {}) {
     }
   };
 }
-var VERSION = "0.1.1";
+var VERSION = "0.1.2";
 
 // src/providers.ts
 var MISSING = new Set(["ENTRY_NOT_FOUND", "VERSION_NOT_FOUND"]);

package/dist/schema.d.ts

@@ -49,9 +49,7 @@ export interface SchemaSource {
  * platform being up. `refresh` exists so a long-lived process can pick up a
  * change without restarting.
  */
-export declare function managedSchemas(vault: Pick<ForgeZero, 'get'> & {
-    schemas?: () => Promise<readonly SchemaRef[]>;
-}, options?: {
+export declare function managedSchemas(vault: Pick<ForgeZero, 'get' | 'list'>, options?: {
     ttlMs?: number;
     now?: () => number;
 }): SchemaSource & {

package/dist/schema.js

@@ -110,32 +110,37 @@ var requestAgent = (socketPath, request) => new Promise((resolveRequest, reject)
   });
   socket.on("error", (cause) => reject(new VaultError("AGENT_UNAVAILABLE", cause.message)));
 });
-var REASSIGN_ON = new Set([410, 421, 502, 503, 504, 530]);
-var DEFAULT_ASSIGN_URL = "https://assign.forgezero.net/v1/assign";
+var DEFAULT_API_URL = "https://api.forgezero.net";
 var DEFAULT_REQUEST_TIMEOUT_MS = 15000;
-var isForgeZeroNode = (hostname) => /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+forgezero\.net$/.test(hostname);
+function apiOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new VaultError("API_URL_INVALID", "apiUrl must be an absolute HTTPS origin.");
+  }
+  const local = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1";
+  if (url.protocol !== "https:" && !(local && url.protocol === "http:") || url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "")
+    throw new VaultError("API_URL_INVALID", "apiUrl must be an HTTPS origin without credentials, path, query or fragment.");
+  return url;
+}
 
 class ForgeZero {
   credential;
-  assignment;
-  assignUrl;
+  apiUrl;
   doFetch;
-  now;
   signer;
   agentTransport;
-  nodeAllowed;
   requestTimeoutMs;
   project;
   environment;
   constructor(options = {}) {
     const credential = options.credential ?? discover(options.discovery);
     this.credential = credential.mode === "managed" && !credential.socketPath ? { ...credential, socketPath: DEFAULT_SOCKET } : credential;
-    this.assignUrl = options.assignUrl ?? DEFAULT_ASSIGN_URL;
+    this.apiUrl = apiOrigin(options.apiUrl ?? DEFAULT_API_URL);
     this.doFetch = options.fetch ?? globalThis.fetch;
-    this.now = options.now ?? Date.now;
     this.signer = options.signer ?? (this.credential.mode === "external" ? signerFromApiKey(this.credential.apiKey) : undefined);
     this.agentTransport = options.agentTransport ?? requestAgent;
-    this.nodeAllowed = options.nodeAllowed ?? isForgeZeroNode;
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     if (!Number.isFinite(this.requestTimeoutMs) || this.requestTimeoutMs < 100 || this.requestTimeoutMs > 120000) {
       throw new VaultError("INVALID_TIMEOUT", "requestTimeoutMs must be between 100 and 120000 milliseconds.");
@@ -143,45 +148,14 @@ class ForgeZero {
     this.project = options.project ?? "default";
     this.environment = options.environment ?? "production";
   }
-  async node() {
-    const now = this.now();
-    if (this.assignment && this.assignment.expiresAt > now)
-      return this.assignment.node;
-    const assignmentUrl = new URL(this.assignUrl);
-    if (this.signer?.keyId && !assignmentUrl.searchParams.has("client")) {
-      assignmentUrl.searchParams.set("client", this.signer.keyId);
-    }
-    const response = await this.doFetch(assignmentUrl, {
-      method: "GET",
-      headers: { accept: "application/json" },
-      signal: AbortSignal.timeout(this.requestTimeoutMs)
-    });
-    if (!response.ok)
-      throw new VaultError("NO_NODE", "No vault node is available right now.");
-    const payload = await response.json().catch(() => null);
-    const hostname = typeof payload?.node === "string" ? payload.node : payload?.node && typeof payload.node === "object" && ("hostname" in payload.node) ? payload.node.hostname : undefined;
-    if (typeof hostname !== "string" || !this.nodeAllowed(hostname)) {
-      throw new VaultError("UNTRUSTED_NODE", "The directory returned an untrusted vault node hostname.");
-    }
-    const ttl = payload?.ttl ?? 60;
-    if (typeof ttl !== "number" || !Number.isFinite(ttl) || ttl < 1 || ttl > 300) {
-      throw new VaultError("INVALID_ASSIGNMENT", "The directory returned an invalid vault-node lease.");
-    }
-    this.assignment = { node: hostname, ttl, expiresAt: now + ttl * 1000 };
-    return hostname;
-  }
-  reassign() {
-    this.assignment = undefined;
-  }
   scope() {
     return `${encodeURIComponent(this.project)}/${encodeURIComponent(this.environment)}`;
   }
-  async request(path, init = {}, retried = false) {
+  async request(path, init = {}) {
     if (this.credential.mode === "managed")
       return this.managedRequest(path, init);
-    const node = await this.node();
     const body = typeof init.body === "string" ? init.body : "";
-    const target = new URL(path, "https://vault.invalid");
+    const target = new URL(path, this.apiUrl);
     const headers = {
       "content-type": "application/json",
       ...init.headers
@@ -195,15 +169,11 @@ class ForgeZero {
         body
       });
     }
-    const response = await this.doFetch(`https://${node}${path}`, {
+    const response = await this.doFetch(target, {
       ...init,
       headers,
       signal: init.signal ?? AbortSignal.timeout(this.requestTimeoutMs)
     });
-    if (REASSIGN_ON.has(response.status) && !retried) {
-      this.reassign();
-      return this.request(path, init, true);
-    }
     const payload = await response.json().catch(() => {
       return;
     });
@@ -284,14 +254,28 @@ class ForgeZero {
     return result.values;
   }
   async derived(name, field) {
-    return this.request(`/v1/entries/${encodeURIComponent(name)}/derived/${encodeURIComponent(field)}${this.scope()}`);
+    throw new VaultError("CUSTODY_WORKFLOW_REQUIRED", "Derived custody keys require an explicit platform custody workflow; an application vault credential cannot request them.");
   }
   async sign(name, field, digest) {
-    return this.request(`/v1/entries/${encodeURIComponent(name)}/sign/${encodeURIComponent(field)}${this.scope()}`, { method: "POST", body: JSON.stringify({ digest }) });
+    throw new VaultError("CUSTODY_WORKFLOW_REQUIRED", "Signing requires an explicit platform custody workflow with its own policy, approval and audit contract.");
   }
   async schemas() {
-    const payload = await this.request(`/v1/schemas${this.scope()}`);
-    return payload.schemas ?? [];
+    const entries = await this.list();
+    const names = entries.map((entry) => entry.name).filter((name) => name.startsWith("__schema__")).map((name) => name.slice("__schema__".length)).filter(Boolean);
+    return Promise.all(names.map(async (name) => {
+      let value;
+      try {
+        value = JSON.parse(await this.get(`__schema__${name}`));
+      } catch (cause) {
+        if (cause instanceof VaultError)
+          throw cause;
+        throw new VaultError("SCHEMA_MALFORMED", `The schema for ${name} is not JSON.`);
+      }
+      if (!Number.isInteger(value.version) || Number(value.version) < 1) {
+        throw new VaultError("SCHEMA_MALFORMED", `The schema for ${name} has no valid version.`);
+      }
+      return { name, version: Number(value.version) };
+    }));
   }
   async list() {
     const result = await this.request(`/v1/vault/${this.scope()}/list`);
@@ -362,7 +346,7 @@ function systemdCredentials(options = {}) {
     }
   };
 }
-var VERSION = "0.1.1";
+var VERSION = "0.1.2";
 
 // src/schema.ts
 function managedSchemas(vault, options = {}) {
@@ -392,7 +376,12 @@ function managedSchemas(vault, options = {}) {
       return value;
     },
     async list() {
-      return await vault.schemas?.() ?? [];
+      const entries = await vault.list();
+      const names = entries.map((entry) => entry.name).filter((name) => name.startsWith("__schema__")).map((name) => name.slice("__schema__".length)).filter(Boolean);
+      return Promise.all(names.map(async (name) => {
+        const resolved = await this.get(name);
+        return { name, version: resolved.version };
+      }));
     }
   };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "Publishing happens from an operator's machine, not CI \u2014 CLAUDE.md records that the absence of CI is deliberate. npm's `provenance` attests a tarball was built by a recognised CI provider from a named commit, so it cannot be produced here: it was set, and the first publish failed with `Automatic provenance generation not supported for provider: null`. A setting that can never be satisfied is worse than none, because it reads as a guarantee nobody is getting. Restore it the day this publishes from CI, and not before.",
   "name": "@forgezero/vault",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -49,7 +49,7 @@
     "@noble/post-quantum": "^0.6.1",
     "@noble/hashes": "^2.2.0"
   },
-  "description": "ForgeZero vault client. Credential discovery, versioned secrets, node assignment.",
+  "description": "ForgeZero vault client. Credential discovery and versioned secrets through one stable API origin.",
   "keywords": [
     "secrets",
     "vault",