@ottochain/sdk 2.4.0 → 2.6.0

package/dist/esm/schema/fiber-app.js

@@ -4,6 +4,121 @@
  * TypeScript-first definitions for fiber apps. This is the source of truth —
  * no JSON, no code generation. Import types directly.
  */
+/**
+ * The wire (and authoring) tag for the `Immutable` policy VARIANT: the bare JSON string
+ * `"Immutable"`. EXACT casing, capital-I — this is the POLICY-LEVEL variant name and is
+ * DISTINCT from the `upgradePolicy` dial VALUE `"immutable"` (lowercase). The chain emits
+ * exactly this capital-I string for `Immutable`, so the SDK must too, byte-for-byte.
+ */
+export const IMMUTABLE_POLICY = 'Immutable';
+/** The names of the 15 policy dials, in declaration order. Used by the projector. */
+const FIBER_POLICY_DIALS = [
+    'selfReproducing',
+    'allowedEffects',
+    'spawnOwnerPolicy',
+    'maxGenerations',
+    'maxSpawnFanout',
+    'acceptedCallers',
+    'sealedStates',
+    'transitionPolicy',
+    'transferPolicy',
+    'dependencyPolicy',
+    'upgradePolicy',
+    'version',
+    'compatibleWith',
+    'interfaces',
+    'migrationAuthority',
+];
+/**
+ * The canonical UNCONSTRAINED policy: omission. Provided as a named export for
+ * readability at call sites — `policy: unconstrained()` documents intent, and projects
+ * to NO `policy` key (identical to leaving `policy` off entirely).
+ */
+export function unconstrained() {
+    return undefined;
+}
+/**
+ * The canonical IMMUTABLE policy: the definition is permanently locked. Projects to the
+ * bare JSON string `"Immutable"` ({@link IMMUTABLE_POLICY}), the chain's `Immutable`
+ * variant tag. Semantically equivalent to `constrained({ upgradePolicy: 'immutable' })`
+ * with no other dial set — which `constrained()`/`projectFiberPolicy()` collapse to the
+ * same string for wire parity (see {@link constrained}).
+ *
+ * @example
+ * ```ts
+ * const def = defineFiberApp({ ...spec, policy: immutable() });
+ * ```
+ */
+export function immutable() {
+    return IMMUTABLE_POLICY;
+}
+/**
+ * Build a CONSTRAINED `FiberPolicy` from any subset of the 15 dials.
+ *
+ * Pass only the dials you want to set. Dials left `undefined`/`null` are dropped so the
+ * result is a clean, minimal object that serializes identically to the chain's
+ * `dropNulls`-stripped `Constrained`. If NO dial is effectively set, this returns
+ * `undefined` (an empty constraint == `Unconstrained`), which projects to no `policy`
+ * key — preserving wire parity.
+ *
+ * CANONICAL COLLAPSE: `constrained({ upgradePolicy: 'immutable' })` with NO other dial set
+ * collapses to the bare string `"Immutable"` ({@link IMMUTABLE_POLICY}), because the chain
+ * collapses that exact `Constrained` into the `Immutable` variant. NOTE the casing: the
+ * collapse triggers on the chain's LOWERCASE upgradePolicy dial value `"immutable"`, and
+ * the result is the capital-I policy-variant tag `"Immutable"`. Signing the dials object
+ * `{ "upgradePolicy": "immutable" }` instead would diverge the canonical (the chain
+ * re-encodes it as `"Immutable"`) and break the create signature. Adding ANY other dial
+ * keeps it a dials object.
+ *
+ * @example
+ * ```ts
+ * const policy = constrained({
+ *   selfReproducing: false,
+ *   maxGenerations: 3,
+ *   allowedEffects: ['EMIT', 'TRANSFER'],
+ *   sealedStates: ['ARCHIVED'],
+ * });
+ * ```
+ */
+export function constrained(dials) {
+    const out = {};
+    for (const k of FIBER_POLICY_DIALS) {
+        const v = dials[k];
+        if (v === undefined || v === null)
+            continue;
+        out[k] = v;
+    }
+    const keys = Object.keys(out);
+    if (keys.length === 0)
+        return undefined;
+    // Canonical collapse: a lone LOWERCASE `upgradePolicy: 'immutable'` (the chain's dial
+    // value) IS the `Immutable` variant — emit the capital-I `"Immutable"` tag, not the dials.
+    if (keys.length === 1 && out.upgradePolicy === 'immutable')
+        return IMMUTABLE_POLICY;
+    return out;
+}
+/**
+ * Project an authoring `policy` value onto the wire form. Returns one of:
+ *   - `undefined` when the policy is (effectively) `Unconstrained` — i.e. omit the `policy`
+ *     key entirely;
+ *   - the bare string `"Immutable"` ({@link IMMUTABLE_POLICY}) for the `Immutable` variant
+ *     (also the collapse of a lone LOWERCASE `upgradePolicy: 'immutable'`); or
+ *   - the minimal `Constrained` dials object otherwise.
+ *
+ * Centralizes the omit-on-unconstrained AND the Immutable-collapse parity rules so every
+ * projection path (`toProtoDefinition`, the genesis manifest) stays consistent.
+ */
+export function projectFiberPolicy(policy) {
+    if (policy === undefined || policy === null)
+        return undefined;
+    // The Immutable variant is already its canonical bare-string wire form.
+    if (policy === IMMUTABLE_POLICY)
+        return IMMUTABLE_POLICY;
+    // Re-run the dial filter so a hand-built object with explicit-undefined/empty dials
+    // collapses to Unconstrained, and a lone `upgradePolicy: 'immutable'` collapses to
+    // `"Immutable"`, exactly like `constrained()` does.
+    return constrained(policy);
+}
 // =============================================================================
 // Helper: defineFiberApp
 // =============================================================================
@@ -31,11 +146,11 @@ export function defineFiberApp(definition) {
 }
 /** Get valid transitions from a given state */
 export function getTransitionsFrom(def, state) {
-    return def.transitions.filter(t => t.from === state);
+    return def.transitions.filter((t) => t.from === state);
 }
 /** Get valid event names from a given state */
 export function getEventsFrom(def, state) {
-    return getTransitionsFrom(def, state).map(t => t.eventName);
+    return getTransitionsFrom(def, state).map((t) => t.eventName);
 }
 /** Check if a state is final */
 export function isFinalState(def, state) {
@@ -62,12 +177,17 @@ export function toProtoDefinition(def) {
     const protoDef = {
         states: {},
         initialState: def.initialState,
-        transitions: def.transitions.map(t => ({
+        transitions: def.transitions.map((t) => ({
             from: t.from,
             to: t.to,
             eventName: t.eventName,
-            guard: t.guard, // Required - Scala has no default
-            effect: t.effect, // Required - Scala has no default
+            // guard/effect are REQUIRED by the Scala `Transition` case class (no defaults). The authoring
+            // `Transition` types them OPTIONAL for ergonomics, so ALWAYS project a concrete value here — an
+            // omitted key would serialize to `undefined`, get dropped, and fail the chain's decode (HTTP 400).
+            // The defaults are the exact shapes the chain's `PublishVersionSigningCanonicalSuite` accepts:
+            // an always-true guard `{"==":[1,1]}` and an empty (no-op) effect `{}`.
+            guard: t.guard ?? { '==': [1, 1] },
+            effect: t.effect ?? {},
             // Chain `Transition.dependencies: Set[UUID]` is REQUIRED (no Scala default), and each
             // element must be a fiber UUID string. A `DependencySpec` object is a build-time-only
             // authoring affordance with no wire representation (concrete dependency UUIDs are per
@@ -90,5 +210,14 @@ export function toProtoDefinition(def) {
     // change the signed digest of an otherwise-identical machine), so it is deliberately NOT emitted
     // (the chain's `StateMachineDefinition.metadata` stays absent → `None`). A caller that genuinely
     // needs on-chain metadata sets `ProtoStateMachineDefinition.metadata` explicitly after conversion.
+    // Fiber constitution. OMIT the `policy` key entirely for `Unconstrained` (the chain
+    // emits nothing for it); emit the bare string `"Immutable"` for `Immutable`; emit a bare
+    // object of only the SET dials for `Constrained`. `projectFiberPolicy` returns `undefined`
+    // for an (effectively) unconstrained policy, so we assign only when it is a real policy —
+    // keeping the wire byte-for-byte identical to the chain's encoding.
+    const policy = projectFiberPolicy(def.policy);
+    if (policy !== undefined) {
+        protoDef.policy = policy;
+    }
     return protoDef;
 }

package/dist/esm/schema/guard-lint.js

@@ -58,11 +58,7 @@ export const LINT_CODES = {
  * The ONLY `$`-prefixed keys the engine injects (`ReservedKeys`). Anything else
  * (`$timestamp`, `$now`, ...) resolves to null on chain.
  */
-export const INJECTED_RESERVED_VARS = new Set([
-    '$ordinal',
-    '$lastSnapshotHash',
-    '$epochProgress',
-]);
+export const INJECTED_RESERVED_VARS = new Set(['$ordinal', '$lastSnapshotHash', '$epochProgress']);
 /**
  * Tags that LOOK like opcodes and appear in real definitions but are NOT valid
  * JLVM operators — metakit mis-decodes each as a literal Map. These are always
@@ -117,11 +113,7 @@ export function lintGuardExpression(node, ctx, path, inDataLiteral = false) {
         const ref = obj.var;
         // The reference may be a string, or `[path, default]`, or (rarely) a
         // nested expression; only string refs carry the patterns we check.
-        const refStr = typeof ref === 'string'
-            ? ref
-            : Array.isArray(ref) && typeof ref[0] === 'string'
-                ? ref[0]
-                : undefined;
+        const refStr = typeof ref === 'string' ? ref : Array.isArray(ref) && typeof ref[0] === 'string' ? ref[0] : undefined;
         if (refStr !== undefined) {
             // rule 1 — unknown reserved `$`-key
             if (refStr.startsWith('$') && !INJECTED_RESERVED_VARS.has(refStr)) {
@@ -150,8 +142,7 @@ export function lintGuardExpression(node, ctx, path, inDataLiteral = false) {
                 });
             }
             // rule 3 — `witness.*` read inside a fiber transition
-            if (ctx.flagWitness &&
-                (refStr === 'witness' || refStr.startsWith('witness.'))) {
+            if (ctx.flagWitness && (refStr === 'witness' || refStr.startsWith('witness.'))) {
                 out.push({
                     app: ctx.app,
                     transition: ctx.transition,

package/dist/esm/schema/guards.js

@@ -17,7 +17,7 @@
  * replacement for `{"===":[{"var":"event.agent"}, {"var":partyVar}]}`.
  */
 export const signerIsParty = (partyVar) => ({
-    in: [{ var: partyVar }, { map: [{ var: "proofs" }, { var: "address" }] }],
+    in: [{ var: partyVar }, { map: [{ var: 'proofs' }, { var: 'address' }] }],
 });
 /** FIBER-transition authorization where ANY of the pinned parties signed (e.g. borrower OR lender). */
 export const signerIsAnyParty = (partyVars) => ({
@@ -29,17 +29,14 @@ export const signerIsAnyParty = (partyVars) => ({
  * The replay-safe replacement for `{"in":[{"var":"event.agent"}, {"var":setVar}]}`.
  */
 export const signerInSet = (setVar) => ({
-    some: [
-        { map: [{ var: "proofs" }, { var: "address" }] },
-        { in: [{ var: "" }, { var: setVar }] },
-    ],
+    some: [{ map: [{ var: 'proofs' }, { var: 'address' }] }, { in: [{ var: '' }, { var: setVar }] }],
 });
 /**
  * FIBER-transition ANTI-SELF guard: NO verified signer is the pinned party (e.g. a proposal author may
  * not vote on their own proposal). The replay-safe replacement for `{"!==":[{"var":"event.agent"}, {"var":partyVar}]}`.
  */
 export const signerIsNotParty = (partyVar) => ({
-    "!": [signerIsParty(partyVar)],
+    '!': [signerIsParty(partyVar)],
 });
 /**
  * FIBER-transition authorization / dedup over a state MAP keyed by address: at least one VERIFIED signer
@@ -50,10 +47,7 @@ export const signerIsNotParty = (partyVar) => ({
  * `{"some":[{"map":[proofs,address]},{">=":[{"get":[mapVar,{"var":""}]}, N]}]}`.
  */
 export const signerHasEntry = (mapVar) => ({
-    some: [
-        { map: [{ var: "proofs" }, { var: "address" }] },
-        { has: [{ var: mapVar }, { var: "" }] },
-    ],
+    some: [{ map: [{ var: 'proofs' }, { var: 'address' }] }, { has: [{ var: mapVar }, { var: '' }] }],
 });
 /**
  * ASSET-op authorization (mintPolicy / burnPolicy / MorphismSpec.guard): the address at `addressVar`
@@ -61,7 +55,7 @@ export const signerHasEntry = (mapVar) => ({
  * `event` or `proofs` — it injects `signers` directly.
  */
 export const assetSignerIs = (addressVar) => ({
-    in: [{ var: addressVar }, { var: "signers" }],
+    in: [{ var: addressVar }, { var: 'signers' }],
 });
 /**
  * EFFECT-KEY BINDING: prove the event's claimed actor (`actorVar`, default `event.agent`) is a
@@ -75,7 +69,7 @@ export const assetSignerIs = (addressVar) => ({
  * both signed and is authorized, and the effect can only write under that one verified key.
  * Structurally identical to {@link signerIsParty}; named for intent + greppability at write sites.
  */
-export const actorIsSigner = (actorVar = "event.agent") => signerIsParty(actorVar);
+export const actorIsSigner = (actorVar = 'event.agent') => signerIsParty(actorVar);
 /**
  * EFFECT-KEY-BINDING membership: the event's claimed actor (`actorVar`, default `event.agent`) is BOTH
  * a CHAIN-VERIFIED signer AND a member of the pinned set `setVar` (e.g. `"state.signers"`,
@@ -86,7 +80,7 @@ export const actorIsSigner = (actorVar = "event.agent") => signerIsParty(actorVa
  * verified-but-unauthorized address as the key (padding a signature/vote tally). `actorInSet` pins both
  * to the same `actorVar`.
  */
-export const actorInSet = (setVar, actorVar = "event.agent") => ({
+export const actorInSet = (setVar, actorVar = 'event.agent') => ({
     and: [actorIsSigner(actorVar), { in: [{ var: actorVar }, { var: setVar }] }],
 });
 /**
@@ -98,7 +92,7 @@ export const actorInSet = (setVar, actorVar = "event.agent") => ({
  * is an authorized member, closing the vote/signature-stuffing gap that bare {@link signerHasEntry}
  * leaves open (which only proves SOME verified signer is a key, not that the written key is).
  */
-export const actorHasEntry = (mapVar, actorVar = "event.agent") => ({
+export const actorHasEntry = (mapVar, actorVar = 'event.agent') => ({
     and: [actorIsSigner(actorVar), { has: [{ var: mapVar }, { var: actorVar }] }],
 });
 /**
@@ -112,9 +106,9 @@ export const actorHasEntry = (mapVar, actorVar = "event.agent") => ({
  */
 export const signerHasReputation = (repMapVar, thresholdVar) => ({
     some: [
-        { map: [{ var: "proofs" }, { var: "address" }] },
+        { map: [{ var: 'proofs' }, { var: 'address' }] },
         {
-            ">=": [{ get: [{ var: repMapVar }, { var: "" }] }, { var: thresholdVar }],
+            '>=': [{ get: [{ var: repMapVar }, { var: '' }] }, { var: thresholdVar }],
         },
     ],
 });
@@ -139,26 +133,23 @@ export const signerHasRole = (roleMapVar) => signerHasEntry(roleMapVar);
  */
 export const signerHasReputationVia = (registryIdVar, thresholdVar) => ({
     if: [
-        { has: [{ var: "machines" }, { var: registryIdVar }] },
+        { has: [{ var: 'machines' }, { var: registryIdVar }] },
         {
             some: [
-                { map: [{ var: "proofs" }, { var: "address" }] },
+                { map: [{ var: 'proofs' }, { var: 'address' }] },
                 {
-                    ">=": [
+                    '>=': [
                         {
                             get: [
                                 {
                                     get: [
                                         {
-                                            get: [
-                                                { get: [{ var: "machines" }, { var: registryIdVar }] },
-                                                "state",
-                                            ],
+                                            get: [{ get: [{ var: 'machines' }, { var: registryIdVar }] }, 'state'],
                                         },
-                                        "reputations",
+                                        'reputations',
                                     ],
                                 },
-                                { var: "" },
+                                { var: '' },
                             ],
                         },
                         { var: thresholdVar },
@@ -179,24 +170,21 @@ export const signerHasReputationVia = (registryIdVar, thresholdVar) => ({
  */
 export const signerHasRoleVia = (registryIdVar, roleField) => ({
     if: [
-        { has: [{ var: "machines" }, { var: registryIdVar }] },
+        { has: [{ var: 'machines' }, { var: registryIdVar }] },
         {
             some: [
-                { map: [{ var: "proofs" }, { var: "address" }] },
+                { map: [{ var: 'proofs' }, { var: 'address' }] },
                 {
                     has: [
                         {
                             get: [
                                 {
-                                    get: [
-                                        { get: [{ var: "machines" }, { var: registryIdVar }] },
-                                        "state",
-                                    ],
+                                    get: [{ get: [{ var: 'machines' }, { var: registryIdVar }] }, 'state'],
                                 },
                                 roleField,
                             ],
                         },
-                        { var: "" },
+                        { var: '' },
                     ],
                 },
             ],
@@ -215,14 +203,25 @@ export const signerHasRoleVia = (registryIdVar, roleField) => ({
  * so a single gated transition is split into a bind step then this assert step. See
  * docs/design/app-hardening-identity-integration.md §5–§6.
  */
+/**
+ * EFFECT-KEY-BINDING dedup over an ARRAY of records: no existing element of the array at `arrayVar`
+ * (e.g. `"state.submissions"`, shaped `[ { addr, value }, … ]`) has its `field` (default `"addr"`)
+ * equal to the actor at `actorVar` (default `"event.agent"`). The array analog of the map-keyed
+ * `{"!":[has(...)]}` dedup — used where the collection is an append-only array of `{addr,…}` records
+ * (there is no `(array,string)` key check, but `none` over the array with a per-element `===` is total).
+ *
+ * The bare-element callback context inside `none` sees each record map directly, so `{get:[{var:""},field]}`
+ * is a valid `(map,string)` read. Pair with an `actorIsSigner`/`actorHasEntry` clause on the same
+ * `actorVar` (the dedup proves "not yet present", not "is the verified signer").
+ */
+export const actorNotInArray = (arrayVar, field = 'addr', actorVar = 'event.agent') => ({
+    none: [{ var: arrayVar }, { '===': [{ get: [{ var: '' }, field] }, { var: actorVar }] }],
+});
 export const depInState = (refVar, requiredState) => ({
     if: [
-        { has: [{ var: "machines" }, { var: refVar }] },
+        { has: [{ var: 'machines' }, { var: refVar }] },
         {
-            "==": [
-                { get: [{ get: [{ var: "machines" }, { var: refVar }] }, "currentStateId"] },
-                requiredState,
-            ],
+            '==': [{ get: [{ get: [{ var: 'machines' }, { var: refVar }] }, 'currentStateId'] }, requiredState],
         },
         false,
     ],

package/dist/esm/templates/asset-policy.js

@@ -0,0 +1,182 @@
+/**
+ * Asset-policy preset builders (§1.1 of the SDK std-lib/templates handoff).
+ *
+ * Each builder is a PURE function that emits the exact {@link CreateAssetPolicy} wire body the chain
+ * re-derives — no `Date.now()`/`Math.random()`/`crypto.randomUUID()`; fixed inputs → fixed output. The
+ * on-chain policy `schemaHash` and `logicHash` are both `RegistryShape.AssetPolicy.computeDigest` over
+ * `behavior`/`supply`/`morphisms`/`stateShape` (no JSON-Logic body), so these presets are pure data.
+ *
+ * Hard invariants (CLAUDE.md rule #1 — the signed canonical is frozen):
+ *  - `behavior` is ALWAYS summed from {@link TOKEN_BEHAVIOR_BITS} (T=16, S=8, C=4, E=2, G=1), never a
+ *    magic literal int.
+ *  - `morphisms` is REQUIRED on the wire (presence required, emptiness meaningful) — emit `{}` when empty,
+ *    NEVER omit it.
+ *  - `supply` is REQUIRED — emit `{}` when there is no supply authority, never omit it.
+ *  - Absent optionals are OMITTED, never emitted as `null`/`undefined` (the chain signs over
+ *    `JCS(dropNulls(payload))`).
+ *
+ * @see src/ottochain/types.ts — CreateAssetPolicy, SupplyPolicy, MorphismSpec, MorphismKind, TOKEN_BEHAVIOR_BITS
+ */
+import { TOKEN_BEHAVIOR_BITS, } from '../ottochain/types.js';
+/** The default mint/burn guard the riverdale presets use: an always-true predicate `{"==":[1,1]}`. */
+const alwaysTrue = () => ({ '==': [1, 1] });
+/** A `PUBLIC`-visibility morphism spec (the riverdale preset visibility). Fresh object per call. */
+const publicMorphism = () => ({ visibility: 'PUBLIC' });
+/** Sum behavior bits from their NAMES — never a magic literal int (CLAUDE.md #1). */
+export function sumBehavior(bits) {
+    return bits.reduce((acc, name) => acc + TOKEN_BEHAVIOR_BITS[name], 0);
+}
+/**
+ * Derive the default `stateShape.typeName`: strip a trailing `.asset` label, PascalCase the remainder
+ * (splitting on `.`/`-`/`_`/space), then append `State`.
+ *   `rvd.asset` → `RvdState`, `goods.asset` → `GoodsState`, `capped.asset` → `CappedState`.
+ */
+export function defaultStateTypeName(name) {
+    const ASSET_SUFFIX = '.asset';
+    const base = name.endsWith(ASSET_SUFFIX) ? name.slice(0, -ASSET_SUFFIX.length) : name;
+    const pascal = base
+        .split(/[.\-_\s]+/)
+        .filter(Boolean)
+        .map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1))
+        .join('');
+    return `${pascal}State`;
+}
+/** Build a {@link SupplyPolicy}, OMITTING every absent field (no `undefined`/`null` keys). */
+function buildSupply(opts) {
+    const supply = {};
+    if (opts.maxSupply !== undefined)
+        supply.maxSupply = opts.maxSupply;
+    if (opts.mintPolicy !== undefined)
+        supply.mintPolicy = opts.mintPolicy;
+    if (opts.burnPolicy !== undefined)
+        supply.burnPolicy = opts.burnPolicy;
+    if (opts.decimals !== undefined)
+        supply.decimals = opts.decimals;
+    return supply;
+}
+/** Assemble the final {@link CreateAssetPolicy}, attaching `metadata` only when present. */
+function assemble(args) {
+    const stateShape = {
+        typeName: args.stateTypeName ?? defaultStateTypeName(args.name),
+        fields: [],
+    };
+    const policy = {
+        name: args.name,
+        version: args.version,
+        behavior: args.behavior,
+        supply: args.supply,
+        morphisms: args.morphisms,
+        stateShape,
+    };
+    if (args.metadata !== undefined)
+        policy.metadata = args.metadata;
+    return policy;
+}
+/**
+ * Fungible currency. Behavior `T|S|C = 28` (transferable + splittable + combinable). Standard morphism
+ * set TRANSFER + FRACTIONALIZE + STAKE (`stakeable`, default true) + BURN (when `burnable`), all PUBLIC.
+ *
+ * Reproduces `riverdale-economy/rvd-policy.json` exactly via
+ * `fungiblePolicy({ name: 'rvd.asset', version: '1.0.0', mintable: true, burnable: true })`.
+ */
+export function fungiblePolicy(p) {
+    const behavior = sumBehavior(['transferable', 'splittable', 'combinable']); // 28
+    const morphisms = {
+        TRANSFER: publicMorphism(),
+        FRACTIONALIZE: publicMorphism(),
+    };
+    if (p.stakeable !== false)
+        morphisms.STAKE = publicMorphism();
+    if (p.burnable)
+        morphisms.BURN = publicMorphism();
+    let mintPolicy;
+    if (p.mintGuard !== undefined)
+        mintPolicy = p.mintGuard;
+    else if (p.mintable)
+        mintPolicy = alwaysTrue();
+    const supply = buildSupply({
+        maxSupply: p.maxSupply,
+        mintPolicy,
+        burnPolicy: p.burnable ? alwaysTrue() : undefined,
+        decimals: p.decimals,
+    });
+    return assemble({
+        name: p.name,
+        version: p.version,
+        behavior,
+        supply,
+        morphisms,
+        stateTypeName: p.stateTypeName,
+        metadata: p.metadata,
+    });
+}
+/**
+ * Non-fungible token. Behavior `T = 16`, or `T|C = 20` with `combinable: true` (the riverdale
+ * `goods.asset`); `transferable: false` drops the T bit (a bound collectible). `morphisms` is `{}` by
+ * default (emitted explicitly, never omitted). Mintable by default ⇒ `supply.mintPolicy = {"==":[1,1]}`.
+ *
+ * Reproduces `riverdale-economy/goods-policy.json` exactly via
+ * `nftPolicy({ name: 'goods.asset', version: '1.0.0', combinable: true })`.
+ */
+export function nftPolicy(p) {
+    const bits = [];
+    if (p.transferable !== false)
+        bits.push('transferable');
+    if (p.combinable)
+        bits.push('combinable');
+    const behavior = sumBehavior(bits);
+    let mintPolicy;
+    if (p.mintGuard !== undefined)
+        mintPolicy = p.mintGuard;
+    else if (p.mintable !== false)
+        mintPolicy = alwaysTrue();
+    const supply = buildSupply({ maxSupply: p.maxSupply, mintPolicy });
+    return assemble({
+        name: p.name,
+        version: p.version,
+        behavior,
+        supply,
+        morphisms: {},
+        stateTypeName: p.stateTypeName,
+        metadata: p.metadata,
+    });
+}
+/**
+ * Soulbound token: non-transferable, governable only (`G = 1`; `+E = 3` when `expirable`). No TRANSFER
+ * morphism (`morphisms: {}`); minting is closed after issue (empty `supply`).
+ */
+export function soulboundPolicy(p) {
+    const bits = ['governable'];
+    if (p.expirable)
+        bits.push('expirable');
+    const behavior = sumBehavior(bits);
+    return assemble({
+        name: p.name,
+        version: p.version,
+        behavior,
+        supply: buildSupply({}), // mint closed after issue
+        morphisms: {}, // non-transferable: no TRANSFER morphism
+        stateTypeName: p.stateTypeName,
+        metadata: p.metadata,
+    });
+}
+/**
+ * Escape hatch: declare `behavior` by NAME (summed from {@link TOKEN_BEHAVIOR_BITS}, never a magic int)
+ * and pass `supply` + `morphisms` through raw. Use when no preset fits.
+ *
+ * Reproduces `riverdale-economy/capped-policy.json` exactly via
+ * `customPolicy({ name: 'capped.asset', version: '1.0.0',
+ *                 behavior: ['transferable', 'splittable', 'combinable'],
+ *                 supply: { maxSupply: 100, mintPolicy: { '==': [1, 1] } }, morphisms: {} })`.
+ */
+export function customPolicy(p) {
+    return assemble({
+        name: p.name,
+        version: p.version,
+        behavior: sumBehavior(p.behavior),
+        supply: p.supply,
+        morphisms: p.morphisms,
+        stateTypeName: p.stateTypeName,
+        metadata: p.metadata,
+    });
+}

package/dist/esm/templates/index.js

@@ -0,0 +1,41 @@
+/**
+ * `@ottochain/sdk/templates` — the fiber & asset authoring template catalog.
+ *
+ * Typed builders that emit the EXACT canonical wire shapes app authors otherwise hand-roll as raw
+ * JSON-Logic (asset policies, versioned machines, effect directives, migrations, seeded state). Every
+ * builder is additive and pure — it returns the same wire shape the chain re-derives, so a template
+ * output signs to byte-identical `JCS(dropNulls(payload))` (CLAUDE.md rule #1). Hand-rolled JSON keeps
+ * working; these just make the recurring shapes typed, named, and mistake-resistant.
+ *
+ * Origin: the fiber-ergonomics program (ottochain `docs/proposals/fiber-ergonomics/`), Phase A — the
+ * `riverdale-economy` e2e is the migration proof (each preset reproduces its checked-in golden JSON).
+ *
+ * @example
+ * import {
+ *   fungiblePolicy, machine, transition, effect, guard,
+ *   transferAsset, triggers, spawn, seedState, seedFields,
+ * } from '@ottochain/sdk/templates';
+ */
+// ─── 1.1 Asset-policy presets ────────────────────────────────────────────────
+// fungiblePolicy / nftPolicy / soulboundPolicy / customPolicy (+ sumBehavior, defaultStateTypeName,
+// BehaviorBitName) — emit a `CreateAssetPolicy`; behavior is summed from TOKEN_BEHAVIOR_BITS, never a literal.
+export * from './asset-policy.js';
+// ─── 1.2 Versioned-machine skeleton + transition()/effect() ──────────────────
+// machine / transition / effect (+ TransitionSpec, MachineSpec, Machine, …). The skeleton owns ONE
+// canonical wire definition, so publish + create cannot drift (verified binding, F9).
+export * from './machine.js';
+// ─── 1.4 Migration helpers ───────────────────────────────────────────────────
+// seedFields / migration — hides the bare-state-root ({"var":""}) foot-gun.
+export * from './migration.js';
+// ─── 1.5 State-shape-with-defaults ───────────────────────────────────────────
+// seedState / declaredFields / StateShape — auto-seed accumulators so no field reads null (F5).
+export * from './state-shape.js';
+// ─── 1.3 Effect-directive builders ───────────────────────────────────────────
+// transferAsset / triggers / spawn / emit / toFiber / toWallet / addDependency / setDependencyActive /
+// RESERVED_EFFECT_KEYS — a typo'd directive is a TS error, not a silent state field (F4).
+export * from '../schema/effects.js';
+// ─── Authorization-guard builders (namespace) ────────────────────────────────
+// `guard.signerIsParty('state.borrower')` reads as intent at the call site.
+export * as guard from '../schema/guards.js';
+// ─── Existing machine/policy primitives re-surfaced for one-import authoring ──
+export { defineFiberApp, toProtoDefinition, constrained, unconstrained, immutable, projectFiberPolicy, } from '../schema/fiber-app.js';