@forgezero/runtime 0.1.1 → 0.1.3

package/dist/queue.js

@@ -14,6 +14,15 @@ class QueueStoppedError extends Error {
   }
 }
 
+class QueueKeyStoppedError extends Error {
+  key;
+  constructor(key) {
+    super(`queue: key ${key} is stopped`);
+    this.key = key;
+    this.name = "QueueKeyStoppedError";
+  }
+}
+
 class TaskCancelledError extends Error {
   constructor() {
     super("queue: task cancelled");
@@ -25,12 +34,19 @@ var DEFAULT_RETRY = {
   backoffMs: (attempt) => Math.min(30000, 2 ** attempt * 100)
 };
 function createQueue(options = {}) {
-  const width = Math.max(1, options.width ?? 8);
+  const width = options.width ?? 8;
   const retry = { ...DEFAULT_RETRY, ...options.retry };
+  if (!Number.isSafeInteger(width) || width < 1) {
+    throw new RangeError("queue: width must be a positive integer");
+  }
+  if (!Number.isSafeInteger(retry.attempts) || retry.attempts < 1) {
+    throw new RangeError("queue: retry attempts must be a positive integer");
+  }
   const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   const lanes = new Map;
   const running = new Set;
   const paused = new Set;
+  const stoppedKeys = new Set;
   let sequence = 0;
   let globallyPaused = false;
   let accepting = true;
@@ -48,8 +64,10 @@ function createQueue(options = {}) {
       idle.shift()();
   };
   function pump() {
-    if (globallyPaused || aborted)
+    if (globallyPaused || aborted) {
+      announceIdle();
       return;
+    }
     for (const [key, lane] of lanes) {
       if (running.size >= width)
         break;
@@ -62,18 +80,21 @@ function createQueue(options = {}) {
   async function execute(key) {
     running.add(key);
     try {
-      for (;; ) {
-        const lane = lanes.get(key);
-        const entry = lane?.[0];
-        if (!entry || globallyPaused || paused.has(key) || aborted)
-          break;
+      const lane = lanes.get(key);
+      const entry = lane?.[0];
+      if (entry && !globallyPaused && !paused.has(key) && !aborted) {
         lane.shift();
         await attempt(entry);
       }
     } finally {
       running.delete(key);
-      if (lanes.get(key)?.length === 0)
+      const remaining = lanes.get(key);
+      if (remaining?.length === 0)
         lanes.delete(key);
+      else if (remaining) {
+        lanes.delete(key);
+        lanes.set(key, remaining);
+      }
       pump();
     }
   }
@@ -95,15 +116,21 @@ function createQueue(options = {}) {
           entry.reject(cause);
           return;
         }
-        await sleep(retry.backoffMs(entry.attempt));
+        const delay = retry.backoffMs(entry.attempt);
+        if (!Number.isFinite(delay) || delay < 0) {
+          failed += 1;
+          entry.reject(new RangeError("queue: retry backoff must be a non-negative finite number"));
+          return;
+        }
+        await sleep(delay);
       }
     }
   }
   return {
-    run(key, handler) {
+    run(key, handler, ...args) {
       const id = `q_${++sequence}`;
-      if (!accepting) {
-        const refused = Promise.reject(new QueueStoppedError);
+      if (!accepting || stoppedKeys.has(key)) {
+        const refused = Promise.reject(accepting ? new QueueKeyStoppedError(key) : new QueueStoppedError);
         refused.catch(() => {
           return;
         });
@@ -118,7 +145,7 @@ function createQueue(options = {}) {
       const entry = {
         id,
         key,
-        run: async () => handler(),
+        run: async () => handler(...args),
         resolve,
         reject,
         attempt: 0,
@@ -142,6 +169,7 @@ function createQueue(options = {}) {
         entry.reject(new TaskCancelledError);
         if (lane.length === 0 && !running.has(key))
           lanes.delete(key);
+        announceIdle();
         return true;
       }
       return false;
@@ -153,6 +181,28 @@ function createQueue(options = {}) {
       paused.delete(key);
       pump();
     },
+    stopKey(key) {
+      stoppedKeys.add(key);
+      paused.delete(key);
+      const lane = lanes.get(key);
+      if (!lane)
+        return 0;
+      let removed = 0;
+      for (const entry of lane.splice(0)) {
+        removed += 1;
+        entry.cancelled = true;
+        entry.reject(new QueueKeyStoppedError(key));
+      }
+      if (!running.has(key))
+        lanes.delete(key);
+      announceIdle();
+      return removed;
+    },
+    startKey(key) {
+      const changed = stoppedKeys.delete(key);
+      pump();
+      return changed;
+    },
     pause() {
       globallyPaused = true;
     },
@@ -170,6 +220,7 @@ function createQueue(options = {}) {
         keys: lanes.size,
         paused: globallyPaused,
         pausedKeys: [...paused],
+        stoppedKeys: [...stoppedKeys],
         completed,
         failed
       };
@@ -181,15 +232,25 @@ function createQueue(options = {}) {
       return new Promise((resolve) => idle.push(resolve));
     },
     async stop(deadlineMs = 30000) {
+      if (!Number.isSafeInteger(deadlineMs) || deadlineMs < 0) {
+        throw new RangeError("queue: stop deadline must be a non-negative integer");
+      }
       accepting = false;
       const before = { completed, failed };
+      globallyPaused = false;
+      paused.clear();
+      pump();
       let timedOut = false;
-      await Promise.race([
-        this.whenIdle(),
-        sleep(deadlineMs).then(() => {
+      let deadlineHandle;
+      const deadline = new Promise((resolve) => {
+        deadlineHandle = setTimeout(() => {
           timedOut = true;
-        })
-      ]);
+          resolve();
+        }, deadlineMs);
+      });
+      await Promise.race([this.whenIdle(), deadline]);
+      if (!timedOut && deadlineHandle !== undefined)
+        clearTimeout(deadlineHandle);
       if (timedOut)
         aborted = true;
       let abandoned = 0;
@@ -199,6 +260,11 @@ function createQueue(options = {}) {
           entry.reject(new QueueStoppedError);
       }
       abandoned += running.size;
+      for (const [key, lane] of lanes) {
+        if (lane.length === 0 && !running.has(key))
+          lanes.delete(key);
+      }
+      announceIdle();
       return {
         completed: completed - before.completed,
         failed: failed - before.failed,
@@ -211,5 +277,6 @@ function createQueue(options = {}) {
 export {
   createQueue,
   TaskCancelledError,
-  QueueStoppedError
+  QueueStoppedError,
+  QueueKeyStoppedError
 };

package/dist/snp.d.ts

@@ -17,10 +17,9 @@
  * ## What this does NOT do
  *
  * It does not verify the signature. Chaining a report to AMD's root needs the
- * VCEK certificate for that specific chip at that specific TCB, fetched from
- * AMD's KDS — a network dependency with its own failure modes, and a
- * hand-rolled ECDSA-P384 verification here would be worse than none because it
- * would produce `verified: true` for a report nobody signed.
+ * VCEK certificate for that specific chip at that specific TCB and is performed
+ * by the API's pinned KDS verifier. Keeping network trust out of this parser
+ * preserves a total byte-to-fields function.
  *
  * So `parseSnpReport` returns the signature bytes and says nothing about them.
  * The caller supplies a verifier, which is the same shape every other trust
@@ -29,8 +28,8 @@
 /** The structure is exactly this long. Anything else is not a report. */
 export declare const REPORT_BYTES = 1184;
 export declare class SnpError extends Error {
-    readonly code: 'BAD_LENGTH' | 'BAD_VERSION' | 'BAD_VMPL';
-    constructor(code: 'BAD_LENGTH' | 'BAD_VERSION' | 'BAD_VMPL', message: string);
+    readonly code: 'BAD_LENGTH' | 'BAD_VERSION' | 'BAD_VMPL' | 'BAD_SIGNATURE_ALGORITHM';
+    constructor(code: 'BAD_LENGTH' | 'BAD_VERSION' | 'BAD_VMPL' | 'BAD_SIGNATURE_ALGORITHM', message: string);
 }
 /**
  * Guest policy bits.
@@ -61,6 +60,8 @@ export interface SnpReport {
     guestSvn: number;
     policy: GuestPolicy;
     vmpl: number;
+    /** 1 is ECDSA P-384 with SHA-384. */
+    signatureAlgorithm: number;
     /** 48 bytes of hex. What the guest actually booted. */
     measurement: string;
     /** 64 bytes of hex. Whatever the guest asked the PSP to bind in — our nonce. */

package/dist/snp.js

@@ -69,19 +69,24 @@ function parseSnpReport(bytes) {
   }
   const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
   const version = view.getUint32(OFFSET.version, true);
-  if (version !== 2 && version !== 3) {
+  if (version !== 2 && version !== 3 && version !== 5) {
     throw new SnpError("BAD_VERSION", `Report version ${version} is not one this parser understands.`);
   }
   const vmpl = view.getUint32(OFFSET.vmpl, true);
   if (vmpl > 3) {
     throw new SnpError("BAD_VMPL", `VMPL ${vmpl} is outside the defined range.`);
   }
+  const signatureAlgorithm = view.getUint32(OFFSET.signatureAlgo, true);
+  if (signatureAlgorithm !== 1) {
+    throw new SnpError("BAD_SIGNATURE_ALGORITHM", `Signature algorithm ${signatureAlgorithm} is not ECDSA P-384 with SHA-384.`);
+  }
   const slice = (offset, length) => hex(bytes.subarray(offset, offset + length));
   return {
     version,
     guestSvn: view.getUint32(OFFSET.guestSvn, true),
     policy: readPolicy(view, OFFSET.policy),
     vmpl,
+    signatureAlgorithm,
     measurement: slice(OFFSET.measurement, 48),
     reportData: slice(OFFSET.reportData, 64),
     hostData: slice(OFFSET.hostData, 32),

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/runtime",
-	"version": "0.1.1",
+	"version": "0.1.3",
 	"type": "module",
 	"publishConfig": {
 		"access": "public"
@@ -59,10 +59,6 @@
 			"types": "./dist/otpauth.d.ts",
 			"default": "./dist/otpauth.js"
 		},
-		"./serial": {
-			"types": "./dist/serial.d.ts",
-			"default": "./dist/serial.js"
-		},
 		"./pipeline": {
 			"types": "./dist/pipeline.d.ts",
 			"default": "./dist/pipeline.js"
@@ -182,7 +178,8 @@
 	},
 	"scripts": {
 		"check": "tsc --noEmit",
-		"build": "bun build src/jobs.ts src/queue.ts src/serial.ts src/outbox.ts src/audit.ts src/backup.ts src/notify.ts src/notify-templates.ts src/calendar.ts src/compliance.ts src/pipeline.ts src/totp.ts src/otpauth.ts src/identity.ts src/slip10.ts src/openssh.ts src/ssh-cert.ts src/importers.ts src/snp.ts src/passkey.ts src/custody-crypto.ts src/custody-share.ts src/phrase.ts src/ssh-agent.ts src/schema.ts src/schema-typebox.ts src/finance/discounts.ts src/finance/money.ts src/finance/storage.ts src/finance/custody.ts src/finance/tax.ts src/finance/derive.ts src/finance/venues.ts src/finance/ledger.ts src/finance/rates.ts src/finance/transfers.ts src/finance/chain.ts src/finance/chain-addresses.ts src/finance/chain-deposits.ts src/finance/chain-withdrawals.ts src/finance/chain-reconcile.ts src/finance/market.ts src/finance/commission.ts --root src --outdir dist --target browser --format esm --packages external && tsc --emitDeclarationOnly --declaration --noEmit false --outDir dist",
+		"prebuild": "rm -rf dist",
+		"build": "bun build src/jobs.ts src/queue.ts src/outbox.ts src/audit.ts src/backup.ts src/notify.ts src/notify-templates.ts src/calendar.ts src/compliance.ts src/pipeline.ts src/totp.ts src/otpauth.ts src/identity.ts src/slip10.ts src/openssh.ts src/ssh-cert.ts src/importers.ts src/snp.ts src/passkey.ts src/custody-crypto.ts src/custody-share.ts src/phrase.ts src/ssh-agent.ts src/schema.ts src/schema-typebox.ts src/finance/discounts.ts src/finance/money.ts src/finance/storage.ts src/finance/custody.ts src/finance/tax.ts src/finance/derive.ts src/finance/venues.ts src/finance/ledger.ts src/finance/rates.ts src/finance/transfers.ts src/finance/chain.ts src/finance/chain-addresses.ts src/finance/chain-deposits.ts src/finance/chain-withdrawals.ts src/finance/chain-reconcile.ts src/finance/market.ts src/finance/commission.ts --root src --outdir dist --target browser --format esm --packages external && tsc --emitDeclarationOnly --declaration --noEmit false --outDir dist",
 		"prepublishOnly": "bun run check && bun run build"
 	},
 	"dependencies": {
@@ -241,13 +238,13 @@
 		"working-days"
 	],
 	"license": "MIT",
-	"homepage": "https://forgezero.net/docs/runtime",
+	"homepage": "https://www.forgezero.net/docs/runtime",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/axxra/forgezero.git",
+		"url": "git+https://github.com/forgezero-net/packages.git",
 		"directory": "packages/runtime"
 	},
-	"bugs": "https://github.com/axxra/forgezero/issues",
+	"bugs": "https://github.com/forgezero-net/packages/issues",
 	"sideEffects": false,
 	"files": [
 		"dist",

package/dist/finance/binance.d.ts

@@ -1,27 +0,0 @@
-import { VenueError, type VenueAdapter, type MarketType, type OrderStatus } from './venues';
-export interface BinanceCredentials {
-    apiKey: string;
-    apiSecret: string;
-}
-export interface BinanceOptions {
-    credentials: BinanceCredentials;
-    /** Override for testnet, or for a test. */
-    hosts?: Partial<Record<MarketType, string>>;
-    fetch?: typeof globalThis.fetch;
-    /**
-     * How far a request may be delayed before Binance refuses it.
-     *
-     * 5s rather than the 60s maximum. A signed order that arrives a minute late
-     * is an order placed into a market that has moved, and accepting it is worse
-     * than being told to retry.
-     */
-    recvWindowMs?: number;
-    now?: () => number;
-}
-/** Binance spells `BTC/USDT` as `BTCUSDT`. Denormalised here and nowhere else. */
-export declare const binanceSymbol: (symbol: string) => string;
-/** Binance statuses → ours. An unknown one is `rejected`, never silently `accepted`. */
-export declare function toOrderStatus(status: string): OrderStatus;
-export declare function createBinanceAdapter(options: BinanceOptions): VenueAdapter;
-/** Turn a Binance error into something that names the actual cause. */
-export declare function readBinanceError(error: unknown): VenueError | undefined;