@forgezero/runtime 0.1.4 → 0.1.6

package/dist/passkey-hybrid.js

@@ -0,0 +1,111 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/passkey-hybrid.ts
+import { ml_dsa65 } from "@noble/post-quantum/ml-dsa.js";
+import { hkdf } from "@noble/hashes/hkdf.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+var PASSKEY_HYBRID_VERSION = 1;
+var PASSKEY_HYBRID_SUITE = "webauthn+prf-ml-dsa-65";
+var PASSKEY_PRF_SALT = new TextEncoder().encode("forgezero:passkey:hybrid-auth:prf:v1");
+var utf8 = (value) => new TextEncoder().encode(value);
+var b64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var un64 = (value) => {
+  if (!/^[A-Za-z0-9_-]+$/.test(value))
+    throw new Error("passkey-hybrid: non-canonical base64url");
+  const normal = value.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(normal.padEnd(Math.ceil(normal.length / 4) * 4, "="));
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+};
+function field(value) {
+  if (value.length > 2048 || /[\0\r\n]/.test(value)) {
+    throw new Error("passkey-hybrid: invalid binding field");
+  }
+  return `${utf8(value).length}:${value}`;
+}
+function passkeyHybridMessage(binding, credentialId) {
+  if (binding.version !== PASSKEY_HYBRID_VERSION || binding.suite !== PASSKEY_HYBRID_SUITE) {
+    throw new Error("passkey-hybrid: unsupported protocol");
+  }
+  if (!/^[A-Za-z0-9_-]{16,1024}$/.test(credentialId)) {
+    throw new Error("passkey-hybrid: invalid credential id");
+  }
+  return utf8([
+    "forgezero-passkey-hybrid-v1",
+    binding.suite,
+    binding.purpose,
+    binding.rpId,
+    binding.origin,
+    binding.challenge,
+    credentialId,
+    binding.userKey,
+    binding.sessionKey,
+    binding.actionRequestKey
+  ].map(field).join(`
+`));
+}
+function keys(prfOutput, credentialId) {
+  if (prfOutput.length !== 32)
+    throw new Error("passkey-hybrid: PRF output must be exactly 32 bytes");
+  const seed = hkdf(sha256, prfOutput, utf8("forgezero:passkey:hybrid-auth:ml-dsa-65:v1"), utf8(`credential:${credentialId.length}:${credentialId}`), 32);
+  try {
+    const pair = ml_dsa65.keygen(seed);
+    return {
+      publicKey: Uint8Array.from(pair.publicKey),
+      secretKey: Uint8Array.from(pair.secretKey)
+    };
+  } finally {
+    seed.fill(0);
+  }
+}
+function createPasskeyHybridProof(prfOutput, binding, credentialId) {
+  const pair = keys(prfOutput, credentialId);
+  try {
+    return {
+      version: PASSKEY_HYBRID_VERSION,
+      suite: PASSKEY_HYBRID_SUITE,
+      credentialId,
+      publicKey: b64(pair.publicKey),
+      signature: b64(ml_dsa65.sign(passkeyHybridMessage(binding, credentialId), pair.secretKey))
+    };
+  } finally {
+    pair.secretKey.fill(0);
+  }
+}
+function verifyPasskeyHybridProof(args) {
+  try {
+    if (args.proof.version !== PASSKEY_HYBRID_VERSION || args.proof.suite !== PASSKEY_HYBRID_SUITE || !Object.keys(args.proof).every((key) => ["version", "suite", "credentialId", "signature"].includes(key)))
+      return false;
+    const publicKey = un64(args.publicKey);
+    const signature = un64(args.proof.signature);
+    if (publicKey.length !== ml_dsa65.lengths.publicKey || signature.length !== ml_dsa65.lengths.signature)
+      return false;
+    if (b64(publicKey) !== args.publicKey || b64(signature) !== args.proof.signature)
+      return false;
+    return ml_dsa65.verify(signature, passkeyHybridMessage(args.binding, args.proof.credentialId), publicKey);
+  } catch {
+    return false;
+  }
+}
+var PASSKEY_ML_DSA_PUBLIC_KEY_BYTES = ml_dsa65.lengths.publicKey;
+var PASSKEY_ML_DSA_SIGNATURE_BYTES = ml_dsa65.lengths.signature;
+export {
+  verifyPasskeyHybridProof,
+  passkeyHybridMessage,
+  createPasskeyHybridProof,
+  PASSKEY_PRF_SALT,
+  PASSKEY_ML_DSA_SIGNATURE_BYTES,
+  PASSKEY_ML_DSA_PUBLIC_KEY_BYTES,
+  PASSKEY_HYBRID_VERSION,
+  PASSKEY_HYBRID_SUITE
+};

package/dist/query.d.ts

@@ -0,0 +1,47 @@
+/** Provider-neutral, function-based typed query contracts. */
+export type QueryIssue = Readonly<{
+    path: string;
+    message: string;
+}>;
+export type QueryDecode<T> = Readonly<{
+    ok: true;
+    value: T;
+}> | Readonly<{
+    ok: false;
+    issues: readonly QueryIssue[];
+}>;
+/** Inputs may coerce wire values; outputs must validate strictly. */
+export interface QueryCodec<T> {
+    readonly schema?: unknown;
+    decode(value: unknown): QueryDecode<T>;
+    encode(value: unknown): QueryDecode<T>;
+}
+export interface QueryContract<Name extends string, Input, Output> {
+    readonly name: Name;
+    readonly input: QueryCodec<Input>;
+    readonly output: QueryCodec<Output>;
+}
+export declare class QueryContractError extends Error {
+    readonly query: string;
+    readonly phase: 'input' | 'output' | 'aborted';
+    readonly issues: readonly QueryIssue[];
+    constructor(query: string, phase: 'input' | 'output' | 'aborted', issues?: readonly QueryIssue[]);
+}
+export declare function defineQuery<const Name extends string, Input, Output>(definition: {
+    name: Name;
+    input: QueryCodec<Input>;
+    output: QueryCodec<Output>;
+}): QueryContract<Name, Input, Output>;
+export interface QueryExecution {
+    readonly signal: AbortSignal;
+}
+export interface QueryImplementation<Context, Output> {
+    execute(context: Context, input: unknown, options?: {
+        signal?: AbortSignal;
+    }): Promise<Output>;
+}
+export declare function implementQuery<Context, Name extends string, Input, Output>(contract: QueryContract<Name, Input, Output>, handler: (context: Context, input: Input, execution: QueryExecution) => Output | Promise<Output>): QueryImplementation<Context, Output> & {
+    readonly contract: typeof contract;
+};
+export type QueryInput<Q> = Q extends QueryContract<string, infer Input, unknown> ? Input : never;
+export type QueryOutput<Q> = Q extends QueryContract<string, unknown, infer Output> ? Output : never;

package/dist/query.js

@@ -0,0 +1,51 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/query.ts
+class QueryContractError extends Error {
+  query;
+  phase;
+  issues;
+  constructor(query, phase, issues = []) {
+    super(`Query ${query} failed ${phase} validation`);
+    this.query = query;
+    this.phase = phase;
+    this.issues = issues;
+    this.name = "QueryContractError";
+  }
+}
+function defineQuery(definition) {
+  if (!definition.name.trim())
+    throw new Error("A query contract requires a stable name");
+  return Object.freeze({ ...definition });
+}
+function implementQuery(contract, handler) {
+  return {
+    contract,
+    async execute(context, rawInput, options = {}) {
+      const signal = options.signal ?? new AbortController().signal;
+      if (signal.aborted)
+        throw new QueryContractError(contract.name, "aborted");
+      const decoded = contract.input.decode(rawInput);
+      if (!decoded.ok)
+        throw new QueryContractError(contract.name, "input", decoded.issues);
+      const rawOutput = await handler(context, decoded.value, { signal });
+      if (signal.aborted)
+        throw new QueryContractError(contract.name, "aborted");
+      const encoded = contract.output.encode(rawOutput);
+      if (!encoded.ok)
+        throw new QueryContractError(contract.name, "output", encoded.issues);
+      return encoded.value;
+    }
+  };
+}
+export {
+  implementQuery,
+  defineQuery,
+  QueryContractError
+};

package/dist/realtime.d.ts

@@ -0,0 +1,68 @@
+export declare const REALTIME_MAX_EVENTS = 100;
+export declare const REALTIME_MAX_EVENT_BYTES: number;
+export declare const REALTIME_MAX_BATCH_BYTES: number;
+export declare const REALTIME_MAX_SOCKETS_PER_SHARD = 1000;
+export declare const REALTIME_MAX_SHARDS_PER_TOPIC = 1024;
+export interface RealtimeEvent {
+    id: string;
+    type: string;
+    payload: unknown;
+}
+export type RealtimePrincipalKind = 'user' | 'node' | 'api-key' | 'service' | 'header';
+export type RealtimeAudience = Readonly<{
+    kind: 'public';
+}> | Readonly<{
+    kind: 'principal';
+    realmId: string;
+    principalKind: RealtimePrincipalKind;
+    principalKey: string;
+    capability: string;
+}> | Readonly<{
+    kind: 'project';
+    realmId: string;
+    projectKey: string;
+    capability: string;
+}> | Readonly<{
+    kind: 'group';
+    realmId: string;
+    group: string;
+    capability: string;
+}>;
+export interface RealtimeBatch {
+    version: 2;
+    batchId: string;
+    topic: string;
+    audience: RealtimeAudience;
+    publishedAtMs: number;
+    events: RealtimeEvent[];
+}
+export declare function validateRealtimeAudience(input: unknown): RealtimeAudience;
+export declare function validateRealtimeBatch(input: unknown): RealtimeBatch;
+export declare const realtimeBatchBytes: (input: unknown) => string;
+export interface RealtimeSubscriptionTicket {
+    version: 2;
+    topic: string;
+    principal: Readonly<{
+        kind: RealtimePrincipalKind;
+        key: string;
+    }>;
+    realmId: string;
+    projectKeys: readonly string[];
+    groups: readonly string[];
+    capabilities: readonly string[];
+    expiresAtSec: number;
+    nonce: string;
+}
+export declare function validateRealtimeSubscriptionTicket(input: unknown, nowSec?: number): RealtimeSubscriptionTicket;
+/**
+ * The edge has no database authority. It may deliver only when the short-lived,
+ * API-issued connection capability contains every coordinate named by the
+ * event audience. Topic equality is handled by the shard; it is not an access
+ * decision.
+ */
+export declare function canReceiveRealtimeAudience(ticket: RealtimeSubscriptionTicket, audience: RealtimeAudience): boolean;
+export declare const realtimeShardKey: (topic: string, shard: number) => string;
+export declare function realtimeHmac(secret: string, message: string): Promise<string>;
+export declare function verifyRealtimeHmac(secret: string, message: string, signature: string): Promise<boolean>;
+export declare function issueRealtimeSubscriptionTicket(secret: string, ticket: RealtimeSubscriptionTicket, nowSec?: number): Promise<string>;
+export declare function verifyRealtimeSubscriptionToken(secret: string, token: string, nowSec?: number): Promise<RealtimeSubscriptionTicket | null>;

package/dist/realtime.js

@@ -0,0 +1,184 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/realtime.ts
+var REALTIME_MAX_EVENTS = 100;
+var REALTIME_MAX_EVENT_BYTES = 64 * 1024;
+var REALTIME_MAX_BATCH_BYTES = 512 * 1024;
+var REALTIME_MAX_SOCKETS_PER_SHARD = 1000;
+var REALTIME_MAX_SHARDS_PER_TOPIC = 1024;
+var ATOM = /^[A-Za-z0-9][A-Za-z0-9_.:@/-]{0,255}$/;
+var PRINCIPAL_KINDS = new Set(["user", "node", "api-key", "service", "header"]);
+var atom = (value) => typeof value === "string" && ATOM.test(value);
+function validateRealtimeAudience(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new Error("Realtime audience must be an object.");
+  const row = input;
+  if (row.kind === "public") {
+    if (Object.keys(row).length !== 1)
+      throw new Error("Public realtime audience has no additional coordinates.");
+    return { kind: "public" };
+  }
+  if (!atom(row.realmId) || !atom(row.capability))
+    throw new Error("Realtime audience scope is invalid.");
+  if (row.kind === "principal" && PRINCIPAL_KINDS.has(row.principalKind) && atom(row.principalKey)) {
+    return {
+      kind: "principal",
+      realmId: row.realmId,
+      principalKind: row.principalKind,
+      principalKey: row.principalKey,
+      capability: row.capability
+    };
+  }
+  if (row.kind === "project" && atom(row.projectKey)) {
+    return { kind: "project", realmId: row.realmId, projectKey: row.projectKey, capability: row.capability };
+  }
+  if (row.kind === "group" && atom(row.group)) {
+    return { kind: "group", realmId: row.realmId, group: row.group, capability: row.capability };
+  }
+  throw new Error("Realtime audience coordinates are invalid.");
+}
+function validateRealtimeBatch(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new Error("Realtime batch must be an object.");
+  const row = input;
+  if (row.version !== 2 || !ATOM.test(row.batchId ?? "") || !ATOM.test(row.topic ?? "") || !Number.isSafeInteger(row.publishedAtMs) || row.publishedAtMs < 0 || !Array.isArray(row.events) || row.events.length < 1 || row.events.length > REALTIME_MAX_EVENTS)
+    throw new Error("Realtime batch coordinates are invalid.");
+  const audience = validateRealtimeAudience(row.audience);
+  const events = row.events.map((event) => {
+    if (!event || typeof event !== "object" || Array.isArray(event))
+      throw new Error("Realtime event must be an object.");
+    const value = event;
+    if (!ATOM.test(value.id ?? "") || !ATOM.test(value.type ?? ""))
+      throw new Error("Realtime event id/type is invalid.");
+    const encoded = JSON.stringify(value.payload);
+    if (encoded === undefined || new TextEncoder().encode(encoded).byteLength > REALTIME_MAX_EVENT_BYTES) {
+      throw new Error("Realtime event payload is too large or not JSON serializable.");
+    }
+    return { id: value.id, type: value.type, payload: value.payload };
+  });
+  if (new Set(events.map(({ id }) => id)).size !== events.length)
+    throw new Error("Realtime event ids must be unique in a batch.");
+  const batch = {
+    version: 2,
+    batchId: row.batchId,
+    topic: row.topic,
+    audience,
+    publishedAtMs: row.publishedAtMs,
+    events
+  };
+  if (new TextEncoder().encode(JSON.stringify(batch)).byteLength > REALTIME_MAX_BATCH_BYTES) {
+    throw new Error("Realtime batch is too large.");
+  }
+  return batch;
+}
+var realtimeBatchBytes = (input) => JSON.stringify(validateRealtimeBatch(input));
+function boundedUniqueAtoms(value, maximum, label) {
+  if (!Array.isArray(value) || value.length > maximum || value.some((item) => !atom(item)) || new Set(value).size !== value.length)
+    throw new Error(`Realtime ticket ${label} are invalid.`);
+  return [...value];
+}
+function validateRealtimeSubscriptionTicket(input, nowSec = Math.floor(Date.now() / 1000)) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new Error("Realtime ticket must be an object.");
+  const row = input;
+  if (row.version !== 2 || !atom(row.topic) || !atom(row.realmId) || !atom(row.nonce) || !row.principal || !PRINCIPAL_KINDS.has(row.principal.kind) || !atom(row.principal.key) || !Number.isSafeInteger(row.expiresAtSec) || row.expiresAtSec <= nowSec || row.expiresAtSec > nowSec + 300)
+    throw new Error("Realtime ticket is invalid or expired.");
+  return {
+    version: 2,
+    topic: row.topic,
+    principal: { kind: row.principal.kind, key: row.principal.key },
+    realmId: row.realmId,
+    projectKeys: boundedUniqueAtoms(row.projectKeys, 32, "project keys"),
+    groups: boundedUniqueAtoms(row.groups, 16, "groups"),
+    capabilities: boundedUniqueAtoms(row.capabilities, 64, "capabilities"),
+    expiresAtSec: row.expiresAtSec,
+    nonce: row.nonce
+  };
+}
+function canReceiveRealtimeAudience(ticket, audience) {
+  if (audience.kind === "public")
+    return true;
+  if (ticket.realmId !== audience.realmId || !ticket.capabilities.includes(audience.capability))
+    return false;
+  if (audience.kind === "principal") {
+    return ticket.principal.kind === audience.principalKind && ticket.principal.key === audience.principalKey;
+  }
+  if (audience.kind === "project")
+    return ticket.projectKeys.includes(audience.projectKey);
+  return ticket.groups.includes(audience.group);
+}
+var realtimeShardKey = (topic, shard) => {
+  if (!ATOM.test(topic) || !Number.isSafeInteger(shard) || shard < 0 || shard >= REALTIME_MAX_SHARDS_PER_TOPIC) {
+    throw new Error("Realtime shard coordinates are invalid.");
+  }
+  return `rt:${topic}:${shard.toString().padStart(4, "0")}`;
+};
+var bytesToHex = (bytes) => [...bytes].map((value) => value.toString(16).padStart(2, "0")).join("");
+var timingEqual = (left, right) => {
+  if (left.length !== right.length)
+    return false;
+  let difference = 0;
+  for (let index = 0;index < left.length; index += 1)
+    difference |= left.charCodeAt(index) ^ right.charCodeAt(index);
+  return difference === 0;
+};
+async function realtimeHmac(secret, message) {
+  if (new TextEncoder().encode(secret).byteLength < 32)
+    throw new Error("Realtime secret must contain at least 32 bytes.");
+  const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return bytesToHex(new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(message))));
+}
+async function verifyRealtimeHmac(secret, message, signature) {
+  return /^[a-f0-9]{64}$/.test(signature) && timingEqual(await realtimeHmac(secret, message), signature);
+}
+var base64url = (value) => {
+  const bytes = new TextEncoder().encode(value);
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var fromBase64url = (value) => {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(normalized + "=".repeat((4 - normalized.length % 4) % 4));
+  return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+};
+async function issueRealtimeSubscriptionTicket(secret, ticket, nowSec = Math.floor(Date.now() / 1000)) {
+  const body = base64url(JSON.stringify(validateRealtimeSubscriptionTicket(ticket, nowSec)));
+  return `${body}.${await realtimeHmac(secret, `ticket
+${body}`)}`;
+}
+async function verifyRealtimeSubscriptionToken(secret, token, nowSec = Math.floor(Date.now() / 1000)) {
+  const [body, signature, ...extra] = token.split(".");
+  if (!body || !signature || extra.length || !await verifyRealtimeHmac(secret, `ticket
+${body}`, signature))
+    return null;
+  try {
+    return validateRealtimeSubscriptionTicket(JSON.parse(fromBase64url(body)), nowSec);
+  } catch {
+    return null;
+  }
+}
+export {
+  verifyRealtimeSubscriptionToken,
+  verifyRealtimeHmac,
+  validateRealtimeSubscriptionTicket,
+  validateRealtimeBatch,
+  validateRealtimeAudience,
+  realtimeShardKey,
+  realtimeHmac,
+  realtimeBatchBytes,
+  issueRealtimeSubscriptionTicket,
+  canReceiveRealtimeAudience,
+  REALTIME_MAX_SOCKETS_PER_SHARD,
+  REALTIME_MAX_SHARDS_PER_TOPIC,
+  REALTIME_MAX_EVENT_BYTES,
+  REALTIME_MAX_EVENTS,
+  REALTIME_MAX_BATCH_BYTES
+};

package/dist/schema-typebox.d.ts

@@ -1,4 +1,5 @@
 import type { TSchema, Static } from '@sinclair/typebox';
+import type { QueryCodec } from './query';
 import { type SchemaValidator } from './schema';
 /**
  * TypeBox implementation of `SchemaValidator`.
@@ -20,5 +21,7 @@ export declare const typebox: SchemaValidator<TSchema>;
  * refusing to start.
  */
 export declare function parse<T extends TSchema>(schema: T, value: unknown): Static<T>;
+/** TypeBox codec for `@forgezero/runtime/query`. */
+export declare function typeboxQueryCodec<T extends TSchema>(schema: T): QueryCodec<Static<T>>;
 export { Type as T } from '@sinclair/typebox';
 export type { TSchema, Static } from '@sinclair/typebox';

package/dist/schema-typebox.js

@@ -21,6 +21,7 @@ var DEFAULT_RESTRICTIONS = {
   maxDepth: 4,
   maxFields: 100,
   maxBytes: 64 * 1024,
+  maxArrayItems: 1000,
   forbidden: ["$ref", "$id", "$dynamicRef", "$dynamicAnchor", "$schema", "definitions", "$defs"]
 };
 function restrictJsonSchema(schema, limits = DEFAULT_RESTRICTIONS) {
@@ -59,8 +60,20 @@ function restrictJsonSchema(schema, limits = DEFAULT_RESTRICTIONS) {
         walk(properties[name], depth + 1, path ? `${path}.${name}` : name);
       }
     }
-    if (record.type === "array" && record.items) {
-      walk(record.items, depth + 1, `${path}[]`);
+    if (record.type === "array") {
+      const maximum = record.maxItems;
+      if (!Number.isInteger(maximum) || maximum < 0) {
+        throw new SchemaError("SCHEMA_ARRAY_UNBOUNDED", "Arrays must declare a finite non-negative integer maxItems.", path || "(root)");
+      }
+      if (maximum > limits.maxArrayItems) {
+        throw new SchemaError("SCHEMA_ARRAY_TOO_LARGE", `Array maxItems ${maximum} exceeds the platform limit of ${limits.maxArrayItems}.`, path || "(root)");
+      }
+      const minimum = record.minItems;
+      if (minimum !== undefined && (!Number.isInteger(minimum) || minimum < 0 || minimum > maximum)) {
+        throw new SchemaError("SCHEMA_ARRAY_BOUNDS_INVALID", "minItems must be a non-negative integer no larger than maxItems.", path || "(root)");
+      }
+      if (record.items)
+        walk(record.items, depth + 1, `${path}[]`);
     }
   };
   walk(schema, 1, "");
@@ -194,7 +207,24 @@ function parse(schema, value) {
   const first = result.errors[0];
   throw new SchemaError("SCHEMA_INVALID", first?.message ?? "Value does not match schema", first?.path);
 }
+function typeboxQueryCodec(schema) {
+  const issues = (value) => [...Value.Errors(schema, value)].map((error) => ({
+    path: error.path || "(root)",
+    message: error.message
+  }));
+  return {
+    schema,
+    decode(value) {
+      const converted = Value.Convert(schema, value);
+      return Value.Check(schema, converted) ? { ok: true, value: Value.Clean(schema, converted) } : { ok: false, issues: issues(converted) };
+    },
+    encode(value) {
+      return Value.Check(schema, value) ? { ok: true, value: Value.Clean(schema, value) } : { ok: false, issues: issues(value) };
+    }
+  };
+}
 export {
+  typeboxQueryCodec,
   typebox,
   parse,
   Type as T

package/dist/schema.d.ts

@@ -38,6 +38,8 @@ export interface Restrictions {
     maxDepth: number;
     maxFields: number;
     maxBytes: number;
+    /** Largest caller-authored array a persisted value may contain. */
+    maxArrayItems: number;
     /** Keywords refused outright, wherever they appear. */
     forbidden: readonly string[];
 }

package/dist/schema.js

@@ -21,6 +21,7 @@ var DEFAULT_RESTRICTIONS = {
   maxDepth: 4,
   maxFields: 100,
   maxBytes: 64 * 1024,
+  maxArrayItems: 1000,
   forbidden: ["$ref", "$id", "$dynamicRef", "$dynamicAnchor", "$schema", "definitions", "$defs"]
 };
 function restrictJsonSchema(schema, limits = DEFAULT_RESTRICTIONS) {
@@ -59,8 +60,20 @@ function restrictJsonSchema(schema, limits = DEFAULT_RESTRICTIONS) {
         walk(properties[name], depth + 1, path ? `${path}.${name}` : name);
       }
     }
-    if (record.type === "array" && record.items) {
-      walk(record.items, depth + 1, `${path}[]`);
+    if (record.type === "array") {
+      const maximum = record.maxItems;
+      if (!Number.isInteger(maximum) || maximum < 0) {
+        throw new SchemaError("SCHEMA_ARRAY_UNBOUNDED", "Arrays must declare a finite non-negative integer maxItems.", path || "(root)");
+      }
+      if (maximum > limits.maxArrayItems) {
+        throw new SchemaError("SCHEMA_ARRAY_TOO_LARGE", `Array maxItems ${maximum} exceeds the platform limit of ${limits.maxArrayItems}.`, path || "(root)");
+      }
+      const minimum = record.minItems;
+      if (minimum !== undefined && (!Number.isInteger(minimum) || minimum < 0 || minimum > maximum)) {
+        throw new SchemaError("SCHEMA_ARRAY_BOUNDS_INVALID", "minItems must be a non-negative integer no larger than maxItems.", path || "(root)");
+      }
+      if (record.items)
+        walk(record.items, depth + 1, `${path}[]`);
     }
   };
   walk(schema, 1, "");

package/package.json

@@ -1,10 +1,10 @@
 {
-	"//": "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.4",
+  "version": "0.1.6",
 	"type": "module",
-	"publishConfig": {
-		"access": "public"
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
 	},
 	"exports": {
 		"./jobs": {
@@ -43,6 +43,14 @@
 			"types": "./dist/schema-typebox.d.ts",
 			"default": "./dist/schema-typebox.js"
 		},
+		"./query": {
+			"types": "./dist/query.d.ts",
+			"default": "./dist/query.js"
+		},
+		"./realtime": {
+			"types": "./dist/realtime.d.ts",
+			"default": "./dist/realtime.js"
+		},
 		"./calendar": {
 			"types": "./dist/calendar.d.ts",
 			"default": "./dist/calendar.js"
@@ -51,6 +59,10 @@
 			"types": "./dist/identity.d.ts",
 			"default": "./dist/identity.js"
 		},
+		"./passkey-hybrid": {
+			"types": "./dist/passkey-hybrid.d.ts",
+			"default": "./dist/passkey-hybrid.js"
+		},
 		"./totp": {
 			"types": "./dist/totp.d.ts",
 			"default": "./dist/totp.js"
@@ -151,10 +163,6 @@
 			"types": "./dist/phrase.d.ts",
 			"default": "./dist/phrase.js"
 		},
-		"./ssh-agent": {
-			"types": "./dist/ssh-agent.d.ts",
-			"default": "./dist/ssh-agent.js"
-		},
 		"./slip10": {
 			"types": "./dist/slip10.d.ts",
 			"default": "./dist/slip10.js"
@@ -179,7 +187,7 @@
 	"scripts": {
 		"check": "tsc --noEmit",
 		"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",
+		"build": "bun build src/query.ts src/realtime.ts 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/passkey-hybrid.ts src/custody-crypto.ts src/custody-share.ts src/phrase.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": {
@@ -242,7 +250,7 @@
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/forgezero-net/packages.git",
-		"directory": "packages/runtime"
+		"directory": "runtime"
 	},
 	"bugs": "https://github.com/forgezero-net/packages/issues",
 	"sideEffects": false,