@forgezero/runtime 0.1.13 → 0.1.15

package/dist/notify-templates.js

@@ -132,7 +132,7 @@ var invitation = defineTemplate({
   data: ["inviter", "organisation", "link", "days"],
   sample: {
     inviter: "Aravind",
-    organisation: "AltPilot",
+    organisation: "Example Company",
     link: "https://forgezero.net/invite?token=abc",
     days: "7"
   },

package/dist/schema-typebox.js

@@ -46,7 +46,40 @@ function restrictJsonSchema(schema, limits = DEFAULT_RESTRICTIONS) {
     if (depth > limits.maxDepth) {
       throw new SchemaError("SCHEMA_TOO_DEEP", `Nesting exceeds ${limits.maxDepth} levels.`, path || "(root)");
     }
-    if (record.type === "object") {
+    const declaredType = Array.isArray(record.type) ? record.type.filter((value) => typeof value === "string") : typeof record.type === "string" ? [record.type] : [];
+    if (declaredType.includes("null") && declaredType.length !== 2) {
+      throw new SchemaError("SCHEMA_NULLABLE_INVALID", "Nullable fields must declare exactly one concrete type and null.", path || "(root)");
+    }
+    if (Array.isArray(record.oneOf) && Array.isArray(record.anyOf)) {
+      throw new SchemaError("SCHEMA_UNION_INVALID", "A schema cannot declare both oneOf and anyOf.", path || "(root)");
+    }
+    const unionKeyword = Array.isArray(record.oneOf) ? "oneOf" : Array.isArray(record.anyOf) ? "anyOf" : undefined;
+    if (unionKeyword) {
+      const variants = record[unionKeyword];
+      const literalUnion = variants.length > 0 && variants.every((variant) => typeof variant === "object" && variant !== null && Object.keys(variant).every((key) => ["const", "title", "description"].includes(key)) && typeof variant.const === "string");
+      if (!literalUnion) {
+        const discriminator = record["x-fz-discriminator"];
+        if (typeof discriminator !== "string" || !/^[A-Za-z_][A-Za-z0-9_-]{0,63}$/.test(discriminator) || variants.length < 2 || variants.length > 10) {
+          throw new SchemaError("SCHEMA_UNION_INVALID", "Tagged unions require x-fz-discriminator and between 2 and 10 closed object variants.", path || "(root)");
+        }
+        const tags = new Set;
+        for (const [index, variant] of variants.entries()) {
+          if (typeof variant !== "object" || variant === null || Array.isArray(variant)) {
+            throw new SchemaError("SCHEMA_UNION_INVALID", "Every tagged-union variant must be an object.", path || "(root)");
+          }
+          const branch = variant;
+          const properties = branch.properties;
+          const tag = properties?.[discriminator]?.const;
+          const required = Array.isArray(branch.required) ? branch.required : [];
+          if (branch.type !== "object" || branch.additionalProperties !== false || typeof tag !== "string" || !required.includes(discriminator) || tags.has(tag)) {
+            throw new SchemaError("SCHEMA_UNION_INVALID", `Tagged-union variant ${index + 1} must require a unique string const at "${discriminator}".`, path || "(root)");
+          }
+          tags.add(tag);
+        }
+      }
+      variants.forEach((variant, index) => walk(variant, depth + 1, `${path || "(root)"}.${unionKeyword}[${index}]`));
+    }
+    if (declaredType.includes("object")) {
       const properties = record.properties ?? {};
       const names = Object.keys(properties);
       fields += names.length;
@@ -60,7 +93,7 @@ function restrictJsonSchema(schema, limits = DEFAULT_RESTRICTIONS) {
         walk(properties[name], depth + 1, path ? `${path}.${name}` : name);
       }
     }
-    if (record.type === "array") {
+    if (declaredType.includes("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)");
@@ -115,30 +148,101 @@ function describeJsonSchema(schema, prefix = "") {
       minimum: property.minimum,
       maximum: property.maximum,
       pattern: property.pattern,
+      minItems: property.minItems,
+      maxItems: property.maxItems,
+      nullable: Array.isArray(property.type) && property.type.includes("null") ? true : undefined,
       derive: deriveAnnotation(property)
     };
     if (kind === "enum") {
-      return { ...field, options: property.enum ?? property.anyOf };
+      return { ...field, options: enumOptions(property) };
     }
+    if (kind === "union")
+      return describeUnion(property, field);
     if (kind === "object") {
       return { ...field, items: describeJsonSchema(property, path) };
     }
     if (kind === "array" && property.items) {
+      const itemSchema = property.items;
       return {
         ...field,
-        items: describeJsonSchema(property.items, path)
+        item: describeProperty(itemSchema, `${path}[]`, "Item", true),
+        items: itemSchema.type === "object" ? describeJsonSchema(itemSchema, `${path}[]`) : undefined
       };
     }
     return field;
   });
 }
+function describeProperty(property, path, label, required) {
+  const kind = fieldKind(property);
+  const field = {
+    path,
+    label: property.title ?? label,
+    kind,
+    required,
+    description: property.description,
+    writeOnly: property.writeOnly === true ? true : undefined,
+    default: property.default,
+    format: property.format,
+    minLength: property.minLength,
+    maxLength: property.maxLength,
+    minimum: property.minimum,
+    maximum: property.maximum,
+    pattern: property.pattern,
+    minItems: property.minItems,
+    maxItems: property.maxItems,
+    derive: deriveAnnotation(property)
+  };
+  if (kind === "enum")
+    return { ...field, options: enumOptions(property) };
+  if (kind === "union")
+    return describeUnion(property, field);
+  if (kind === "object")
+    return { ...field, items: describeJsonSchema(property, path) };
+  if (kind === "array" && property.items) {
+    const itemSchema = property.items;
+    return {
+      ...field,
+      item: describeProperty(itemSchema, `${path}[]`, "Item", true),
+      items: itemSchema.type === "object" ? describeJsonSchema(itemSchema, `${path}[]`) : undefined
+    };
+  }
+  return field;
+}
+function enumOptions(property) {
+  if (Array.isArray(property.enum))
+    return property.enum.filter((value) => typeof value === "string");
+  if (Array.isArray(property.anyOf))
+    return property.anyOf.flatMap((value) => typeof value === "object" && value !== null && typeof value.const === "string" ? [value.const] : []);
+  return [];
+}
+function describeUnion(property, field) {
+  const discriminator = property["x-fz-discriminator"];
+  const raw = Array.isArray(property.oneOf) ? property.oneOf : property.anyOf;
+  return {
+    ...field,
+    discriminator,
+    variants: raw.map((variant) => {
+      const properties = variant.properties;
+      const value = properties[discriminator].const;
+      return {
+        value,
+        label: variant.title ?? humanise(value),
+        fields: describeJsonSchema(variant, field.path)
+      };
+    })
+  };
+}
 function fieldKind(property) {
   if (Array.isArray(property.enum))
     return "enum";
   if (Array.isArray(property.anyOf) && property.anyOf.every((m) => typeof m === "object" && m !== null && ("const" in m))) {
     return "enum";
   }
-  switch (property.type) {
+  if ((Array.isArray(property.oneOf) || Array.isArray(property.anyOf)) && typeof property["x-fz-discriminator"] === "string") {
+    return "union";
+  }
+  const declared = Array.isArray(property.type) ? property.type.find((value) => value !== "null") : property.type;
+  switch (declared) {
     case "string":
       return "string";
     case "number":
@@ -160,12 +264,17 @@ function humanise(name) {
   return spaced.charAt(0).toUpperCase() + spaced.slice(1);
 }
 function readableFields(fields) {
-  return fields.filter((field) => !field.writeOnly).map((field) => field.items ? { ...field, items: readableFields(field.items) } : field);
+  return fields.filter((field) => !field.writeOnly).map((field) => ({
+    ...field,
+    items: field.items ? readableFields(field.items) : field.items,
+    variants: field.variants?.map((variant) => ({ ...variant, fields: readableFields(variant.fields) }))
+  }));
 }
 function writeOnlyPaths(fields) {
   return fields.flatMap((field) => [
     ...field.writeOnly ? [field.path] : [],
-    ...field.items ? writeOnlyPaths(field.items) : []
+    ...field.items ? writeOnlyPaths(field.items) : [],
+    ...field.variants ? field.variants.flatMap((variant) => writeOnlyPaths(variant.fields)) : []
   ]);
 }
 var SCHEMA_VERSION = 1;

package/dist/schema.d.ts

@@ -44,7 +44,7 @@ export interface Restrictions {
     forbidden: readonly string[];
 }
 export declare const DEFAULT_RESTRICTIONS: Restrictions;
-export type FieldKind = 'string' | 'number' | 'integer' | 'boolean' | 'enum' | 'array' | 'object' | 'unknown';
+export type FieldKind = 'string' | 'number' | 'integer' | 'boolean' | 'enum' | 'union' | 'array' | 'object' | 'unknown';
 /**
  * One rendered field. Deliberately flat and framework-agnostic: the admin UI
  * maps this to inputs, and nothing here knows what a component is.
@@ -72,6 +72,19 @@ export interface FormField {
     pattern?: string;
     /** `array` and `object` only — the shape of each child. */
     items?: readonly FormField[];
+    /** A bounded tagged union. The discriminator is always a required string literal. */
+    discriminator?: string;
+    variants?: readonly {
+        value: string;
+        label: string;
+        fields: readonly FormField[];
+    }[];
+    /** `array` only — one recursively renderable item descriptor. */
+    item?: FormField;
+    minItems?: number;
+    maxItems?: number;
+    /** A nullable field still retains its concrete kind. */
+    nullable?: boolean;
     /**
      * ForgeZero generates this value; the tenant never types it and never holds
      * it. Carried through from the schema's `x-fz-derive` annotation.

package/dist/schema.js

@@ -46,7 +46,40 @@ function restrictJsonSchema(schema, limits = DEFAULT_RESTRICTIONS) {
     if (depth > limits.maxDepth) {
       throw new SchemaError("SCHEMA_TOO_DEEP", `Nesting exceeds ${limits.maxDepth} levels.`, path || "(root)");
     }
-    if (record.type === "object") {
+    const declaredType = Array.isArray(record.type) ? record.type.filter((value) => typeof value === "string") : typeof record.type === "string" ? [record.type] : [];
+    if (declaredType.includes("null") && declaredType.length !== 2) {
+      throw new SchemaError("SCHEMA_NULLABLE_INVALID", "Nullable fields must declare exactly one concrete type and null.", path || "(root)");
+    }
+    if (Array.isArray(record.oneOf) && Array.isArray(record.anyOf)) {
+      throw new SchemaError("SCHEMA_UNION_INVALID", "A schema cannot declare both oneOf and anyOf.", path || "(root)");
+    }
+    const unionKeyword = Array.isArray(record.oneOf) ? "oneOf" : Array.isArray(record.anyOf) ? "anyOf" : undefined;
+    if (unionKeyword) {
+      const variants = record[unionKeyword];
+      const literalUnion = variants.length > 0 && variants.every((variant) => typeof variant === "object" && variant !== null && Object.keys(variant).every((key) => ["const", "title", "description"].includes(key)) && typeof variant.const === "string");
+      if (!literalUnion) {
+        const discriminator = record["x-fz-discriminator"];
+        if (typeof discriminator !== "string" || !/^[A-Za-z_][A-Za-z0-9_-]{0,63}$/.test(discriminator) || variants.length < 2 || variants.length > 10) {
+          throw new SchemaError("SCHEMA_UNION_INVALID", "Tagged unions require x-fz-discriminator and between 2 and 10 closed object variants.", path || "(root)");
+        }
+        const tags = new Set;
+        for (const [index, variant] of variants.entries()) {
+          if (typeof variant !== "object" || variant === null || Array.isArray(variant)) {
+            throw new SchemaError("SCHEMA_UNION_INVALID", "Every tagged-union variant must be an object.", path || "(root)");
+          }
+          const branch = variant;
+          const properties = branch.properties;
+          const tag = properties?.[discriminator]?.const;
+          const required = Array.isArray(branch.required) ? branch.required : [];
+          if (branch.type !== "object" || branch.additionalProperties !== false || typeof tag !== "string" || !required.includes(discriminator) || tags.has(tag)) {
+            throw new SchemaError("SCHEMA_UNION_INVALID", `Tagged-union variant ${index + 1} must require a unique string const at "${discriminator}".`, path || "(root)");
+          }
+          tags.add(tag);
+        }
+      }
+      variants.forEach((variant, index) => walk(variant, depth + 1, `${path || "(root)"}.${unionKeyword}[${index}]`));
+    }
+    if (declaredType.includes("object")) {
       const properties = record.properties ?? {};
       const names = Object.keys(properties);
       fields += names.length;
@@ -60,7 +93,7 @@ function restrictJsonSchema(schema, limits = DEFAULT_RESTRICTIONS) {
         walk(properties[name], depth + 1, path ? `${path}.${name}` : name);
       }
     }
-    if (record.type === "array") {
+    if (declaredType.includes("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)");
@@ -115,30 +148,101 @@ function describeJsonSchema(schema, prefix = "") {
       minimum: property.minimum,
       maximum: property.maximum,
       pattern: property.pattern,
+      minItems: property.minItems,
+      maxItems: property.maxItems,
+      nullable: Array.isArray(property.type) && property.type.includes("null") ? true : undefined,
       derive: deriveAnnotation(property)
     };
     if (kind === "enum") {
-      return { ...field, options: property.enum ?? property.anyOf };
+      return { ...field, options: enumOptions(property) };
     }
+    if (kind === "union")
+      return describeUnion(property, field);
     if (kind === "object") {
       return { ...field, items: describeJsonSchema(property, path) };
     }
     if (kind === "array" && property.items) {
+      const itemSchema = property.items;
       return {
         ...field,
-        items: describeJsonSchema(property.items, path)
+        item: describeProperty(itemSchema, `${path}[]`, "Item", true),
+        items: itemSchema.type === "object" ? describeJsonSchema(itemSchema, `${path}[]`) : undefined
       };
     }
     return field;
   });
 }
+function describeProperty(property, path, label, required) {
+  const kind = fieldKind(property);
+  const field = {
+    path,
+    label: property.title ?? label,
+    kind,
+    required,
+    description: property.description,
+    writeOnly: property.writeOnly === true ? true : undefined,
+    default: property.default,
+    format: property.format,
+    minLength: property.minLength,
+    maxLength: property.maxLength,
+    minimum: property.minimum,
+    maximum: property.maximum,
+    pattern: property.pattern,
+    minItems: property.minItems,
+    maxItems: property.maxItems,
+    derive: deriveAnnotation(property)
+  };
+  if (kind === "enum")
+    return { ...field, options: enumOptions(property) };
+  if (kind === "union")
+    return describeUnion(property, field);
+  if (kind === "object")
+    return { ...field, items: describeJsonSchema(property, path) };
+  if (kind === "array" && property.items) {
+    const itemSchema = property.items;
+    return {
+      ...field,
+      item: describeProperty(itemSchema, `${path}[]`, "Item", true),
+      items: itemSchema.type === "object" ? describeJsonSchema(itemSchema, `${path}[]`) : undefined
+    };
+  }
+  return field;
+}
+function enumOptions(property) {
+  if (Array.isArray(property.enum))
+    return property.enum.filter((value) => typeof value === "string");
+  if (Array.isArray(property.anyOf))
+    return property.anyOf.flatMap((value) => typeof value === "object" && value !== null && typeof value.const === "string" ? [value.const] : []);
+  return [];
+}
+function describeUnion(property, field) {
+  const discriminator = property["x-fz-discriminator"];
+  const raw = Array.isArray(property.oneOf) ? property.oneOf : property.anyOf;
+  return {
+    ...field,
+    discriminator,
+    variants: raw.map((variant) => {
+      const properties = variant.properties;
+      const value = properties[discriminator].const;
+      return {
+        value,
+        label: variant.title ?? humanise(value),
+        fields: describeJsonSchema(variant, field.path)
+      };
+    })
+  };
+}
 function fieldKind(property) {
   if (Array.isArray(property.enum))
     return "enum";
   if (Array.isArray(property.anyOf) && property.anyOf.every((m) => typeof m === "object" && m !== null && ("const" in m))) {
     return "enum";
   }
-  switch (property.type) {
+  if ((Array.isArray(property.oneOf) || Array.isArray(property.anyOf)) && typeof property["x-fz-discriminator"] === "string") {
+    return "union";
+  }
+  const declared = Array.isArray(property.type) ? property.type.find((value) => value !== "null") : property.type;
+  switch (declared) {
     case "string":
       return "string";
     case "number":
@@ -160,12 +264,17 @@ function humanise(name) {
   return spaced.charAt(0).toUpperCase() + spaced.slice(1);
 }
 function readableFields(fields) {
-  return fields.filter((field) => !field.writeOnly).map((field) => field.items ? { ...field, items: readableFields(field.items) } : field);
+  return fields.filter((field) => !field.writeOnly).map((field) => ({
+    ...field,
+    items: field.items ? readableFields(field.items) : field.items,
+    variants: field.variants?.map((variant) => ({ ...variant, fields: readableFields(variant.fields) }))
+  }));
 }
 function writeOnlyPaths(fields) {
   return fields.flatMap((field) => [
     ...field.writeOnly ? [field.path] : [],
-    ...field.items ? writeOnlyPaths(field.items) : []
+    ...field.items ? writeOnlyPaths(field.items) : [],
+    ...field.variants ? field.variants.flatMap((variant) => writeOnlyPaths(variant.fields)) : []
   ]);
 }
 var SCHEMA_VERSION = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgezero/runtime",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "type": "module",
   "publishConfig": {
     "access": "public",
@@ -75,10 +75,6 @@
       "types": "./dist/pipeline.d.ts",
       "default": "./dist/pipeline.js"
     },
-    "./compliance": {
-      "types": "./dist/compliance.d.ts",
-      "default": "./dist/compliance.js"
-    },
     "./finance/discounts": {
       "types": "./dist/finance/discounts.d.ts",
       "default": "./dist/finance/discounts.js"
@@ -91,62 +87,10 @@
       "types": "./dist/finance/storage.d.ts",
       "default": "./dist/finance/storage.js"
     },
-    "./finance/custody": {
-      "types": "./dist/finance/custody.d.ts",
-      "default": "./dist/finance/custody.js"
-    },
     "./finance/tax": {
       "types": "./dist/finance/tax.d.ts",
       "default": "./dist/finance/tax.js"
     },
-    "./finance/derive": {
-      "types": "./dist/finance/derive.d.ts",
-      "default": "./dist/finance/derive.js"
-    },
-    "./finance/venues": {
-      "types": "./dist/finance/venues.d.ts",
-      "default": "./dist/finance/venues.js"
-    },
-    "./finance/ledger": {
-      "types": "./dist/finance/ledger.d.ts",
-      "default": "./dist/finance/ledger.js"
-    },
-    "./finance/rates": {
-      "types": "./dist/finance/rates.d.ts",
-      "default": "./dist/finance/rates.js"
-    },
-    "./finance/transfers": {
-      "types": "./dist/finance/transfers.d.ts",
-      "default": "./dist/finance/transfers.js"
-    },
-    "./finance/chain": {
-      "types": "./dist/finance/chain.d.ts",
-      "default": "./dist/finance/chain.js"
-    },
-    "./finance/chain-addresses": {
-      "types": "./dist/finance/chain-addresses.d.ts",
-      "default": "./dist/finance/chain-addresses.js"
-    },
-    "./finance/chain-deposits": {
-      "types": "./dist/finance/chain-deposits.d.ts",
-      "default": "./dist/finance/chain-deposits.js"
-    },
-    "./finance/chain-withdrawals": {
-      "types": "./dist/finance/chain-withdrawals.d.ts",
-      "default": "./dist/finance/chain-withdrawals.js"
-    },
-    "./finance/chain-reconcile": {
-      "types": "./dist/finance/chain-reconcile.d.ts",
-      "default": "./dist/finance/chain-reconcile.js"
-    },
-    "./finance/market": {
-      "types": "./dist/finance/market.d.ts",
-      "default": "./dist/finance/market.js"
-    },
-    "./finance/commission": {
-      "types": "./dist/finance/commission.d.ts",
-      "default": "./dist/finance/commission.js"
-    },
     "./passkey": {
       "types": "./dist/passkey.d.ts",
       "default": "./dist/passkey.js"
@@ -190,7 +134,7 @@
     "prepublishOnly": "bun ../tools/package-task.ts prepublish runtime"
   },
   "dependencies": {
-    "@forgezero/access": "^0.1.8"
+    "@forgezero/access": "^0.1.10"
   },
   "peerDependencies": {
     "@noble/ciphers": "^2.2.0",

package/dist/compliance.d.ts

@@ -1,172 +0,0 @@
-/**
- * Screening — the stage that already has a seat.
- *
- * `@forgezero/runtime/finance/transfers` reserved position zero and has been running a
- * pass-everything placeholder there since before this file existed. That
- * ordering is the whole reason this is a drop-in: nothing about deposits or
- * withdrawals changes, and the audit trail already records the stage running.
- *
- * ## Screening is a DECISION RECORD, not a boolean
- *
- * The value of compliance work six months later is being able to say why a
- * transfer was allowed — not just that it was. A screen that returns true or
- * false gives an auditor nothing, so every check produces a verdict with the
- * rules that fired, the risk it scored and the list version it was screened
- * against. That record is the deliverable; the refusal is a side effect.
- *
- * ## Fail CLOSED on an unavailable list, and say so
- *
- * A sanctions list that cannot be reached is not "no hits". Treating an
- * unreachable provider as a pass is how sanctioned money moves during an
- * outage, and it is invisible afterwards because the trail says allowed. So an
- * unavailable list refuses with a retryable status — the transfer waits rather
- * than proceeding unscreened.
- *
- * ## What this deliberately does NOT do
- *
- * No list is bundled. A sanctions list embedded in a package is out of date the
- * day it publishes, and being out of date is the only failure mode that
- * matters. The provider is injected, and `staticList` exists for tests and for
- * an operator's own denylist — never as the primary source.
- */
-export declare class ComplianceError extends Error {
-    readonly code: 'LIST_UNAVAILABLE' | 'BAD_SUBJECT';
-    constructor(code: 'LIST_UNAVAILABLE' | 'BAD_SUBJECT', message: string);
-}
-export declare const RISK_LEVELS: readonly ["low", "medium", "high", "prohibited"];
-export type RiskLevel = (typeof RISK_LEVELS)[number];
-export declare const VERIFICATION_TIERS: readonly ["none", "basic", "verified", "enhanced"];
-export type VerificationTier = (typeof VERIFICATION_TIERS)[number];
-export interface Subject {
-    /** The account being screened. */
-    owner: string;
-    /** Counterparty address, for a transfer. */
-    address?: string;
-    network?: string;
-    /** Value in USD, so a threshold rule can fire. */
-    usdValue?: number;
-    direction?: 'deposit' | 'withdrawal';
-    /** How far the account has verified. Drives the tier rules. */
-    tier?: VerificationTier;
-    /** Anything a rule wants — country, name, date of birth. */
-    attributes?: Record<string, string>;
-}
-export interface ListEntry {
-    /** Address, name or identifier this entry matches. */
-    value: string;
-    kind: 'address' | 'name' | 'country';
-    /** Which list it came from — OFAC, an internal denylist, a chain analytics feed. */
-    source: string;
-    reason?: string;
-}
-export interface ScreeningList {
-    /** Bumped whenever the list content changes. Recorded on every verdict. */
-    readonly version: string;
-    /** Throws `ComplianceError('LIST_UNAVAILABLE')` rather than returning empty. */
-    match(subject: Subject): Promise<ListEntry[]>;
-}
-export interface RuleHit {
-    rule: string;
-    risk: RiskLevel;
-    detail: string;
-}
-export interface Rule {
-    name: string;
-    /** Returns a hit, or undefined when the rule does not fire. */
-    check(subject: Subject): RuleHit | undefined | Promise<RuleHit | undefined>;
-}
-/**
- * A transfer above a threshold for the tier the account has reached.
- *
- * Tiered rather than one global limit, because the whole point of verification
- * is that it raises what an account may move. A single threshold means either
- * verified accounts are throttled or unverified ones are not.
- */
-export declare const tierLimitRule: (limits: Partial<Record<VerificationTier, number>>) => Rule;
-/** A jurisdiction the platform will not serve. */
-export declare const countryRule: (prohibited: readonly string[]) => Rule;
-/**
- * A deposit from an address that has never been seen, above a threshold.
- *
- * Weak on its own and useful in combination — it is the kind of signal that
- * raises a transfer to review rather than refusing it, which is why it scores
- * `medium` and not higher.
- */
-export declare const newCounterpartyRule: (args: {
-    aboveUsd: number;
-    isKnown: (address: string) => boolean | Promise<boolean>;
-}) => Rule;
-export interface Verdict {
-    decision: 'allow' | 'review' | 'refuse';
-    risk: RiskLevel;
-    hits: RuleHit[];
-    listMatches: ListEntry[];
-    /** Which list version this was screened against. The auditable part. */
-    listVersion: string;
-    screenedAtMs: number;
-    subject: Subject;
-}
-export interface ScreenOptions {
-    list?: ScreeningList;
-    rules?: readonly Rule[];
-    /** At or above this, the transfer is held for a human rather than refused. */
-    reviewAt?: RiskLevel;
-    now?: () => number;
-}
-/**
- * Screen a subject and produce a verdict.
- *
- * A list match is always `prohibited` — that is what a sanctions list means,
- * and softening it to "high risk, review it" is the decision nobody should be
- * able to make quietly in a config file. Rules can only ever raise the level
- * arrived at, never lower it.
- */
-export declare function screen(subject: Subject, options?: ScreenOptions): Promise<Verdict>;
-export interface StageOptions extends ScreenOptions {
-    /** Called for every verdict, allowed or not. The case record. */
-    record?: (verdict: Verdict) => void | Promise<void>;
-    /** Whether a `review` verdict has already been approved by a human. */
-    isApproved?: (subject: Subject) => boolean | Promise<boolean>;
-}
-/**
- * The screening stage, shaped for `@forgezero/runtime/finance/transfers`.
- *
- * Drops into the seat that was reserved at order zero. Nothing else changes —
- * which was the entire point of building the pipeline before the policy.
- *
- * EVERY verdict is recorded, including allowances. A trail of refusals answers
- * "what did we stop" and not "what did we decide", and the second question is
- * the one an auditor asks.
- */
-export declare function screeningStage(options?: StageOptions): {
-    name: string;
-    order: number;
-    run(transfer: {
-        owner: string;
-        direction: "deposit" | "withdrawal";
-        address?: string;
-        network?: string;
-        amount: {
-            units: bigint;
-            asset: string;
-        };
-        context?: Record<string, unknown>;
-    }): Promise<{
-        screenedAtMs: number;
-        risk: "low" | "medium" | "high" | "prohibited";
-        listVersion: string;
-    }>;
-};
-/**
- * A list held in memory.
- *
- * For tests, and for an operator's own denylist alongside a real feed — never
- * as the primary source. A sanctions list bundled into a package is out of date
- * the day it publishes, and being out of date is the only failure mode that
- * matters here.
- */
-export declare function staticList(entries: readonly ListEntry[], version?: string): ScreeningList;
-/** Combine several lists. Any one being unavailable fails the whole screen. */
-export declare function combineLists(...lists: readonly ScreeningList[]): ScreeningList;
-/** A list that is not configured yet. Refuses, so nothing runs unscreened by accident. */
-export declare const unavailableList: (reason: string) => ScreeningList;