@forgezero/runtime 0.1.14 → 0.1.16

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.14",
+  "version": "0.1.16",
   "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.9"
+    "@forgezero/access": "^0.1.11"
   },
   "peerDependencies": {
     "@noble/ciphers": "^2.2.0",
@@ -256,9 +200,6 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE",
-    "contracts/src",
-    "contracts/test",
-    "contracts/foundry.toml"
+    "LICENSE"
   ]
 }

package/contracts/foundry.toml

@@ -1,9 +0,0 @@
-[profile.default]
-src = "src"
-test = "test"
-out = "out"
-libs = []
-solc_version = "0.8.24"
-optimizer = true
-optimizer_runs = 200
-evm_version = "shanghai"