@ottochain/sdk 2.2.5 → 2.3.0

package/dist/esm/generated/ottochain/v1/records.js

@@ -6,6 +6,7 @@
 /* eslint-disable */
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import { Value } from "../../google/protobuf/struct.js";
+import { RegistryEntry, SchemaBinding } from "./common.js";
 import { AccessControlPolicy, EventReceipt, FiberLogEntry, FiberStatus, fiberStatusFromJSON, fiberStatusToJSON, fiberStatusToNumber, ScriptInvocation, StateMachineDefinition, } from "./fiber.js";
 export const protobufPackage = "ottochain.v1";
 function createBaseStateMachineFiberRecord() {
@@ -24,6 +25,7 @@ function createBaseStateMachineFiberRecord() {
         lastReceipt: undefined,
         parentFiberId: undefined,
         childFiberIds: [],
+        schemaBinding: undefined,
     };
 }
 export const StateMachineFiberRecord = {
@@ -70,6 +72,9 @@ export const StateMachineFiberRecord = {
         for (const v of message.childFiberIds) {
             writer.uint32(114).string(v);
         }
+        if (message.schemaBinding !== undefined) {
+            SchemaBinding.encode(message.schemaBinding, writer.uint32(122).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -177,6 +182,13 @@ export const StateMachineFiberRecord = {
                     message.childFiberIds.push(reader.string());
                     continue;
                 }
+                case 15: {
+                    if (tag !== 122) {
+                        break;
+                    }
+                    message.schemaBinding = SchemaBinding.decode(reader, reader.uint32());
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -245,6 +257,11 @@ export const StateMachineFiberRecord = {
                 : globalThis.Array.isArray(object?.child_fiber_ids)
                     ? object.child_fiber_ids.map((e) => globalThis.String(e))
                     : [],
+            schemaBinding: isSet(object.schemaBinding)
+                ? SchemaBinding.fromJSON(object.schemaBinding)
+                : isSet(object.schema_binding)
+                    ? SchemaBinding.fromJSON(object.schema_binding)
+                    : undefined,
         };
     },
     toJSON(message) {
@@ -291,6 +308,9 @@ export const StateMachineFiberRecord = {
         if (message.childFiberIds?.length) {
             obj.childFiberIds = message.childFiberIds;
         }
+        if (message.schemaBinding !== undefined) {
+            obj.schemaBinding = SchemaBinding.toJSON(message.schemaBinding);
+        }
         return obj;
     },
     create(base) {
@@ -316,6 +336,9 @@ export const StateMachineFiberRecord = {
             : undefined;
         message.parentFiberId = object.parentFiberId ?? undefined;
         message.childFiberIds = object.childFiberIds?.map((e) => e) || [];
+        message.schemaBinding = (object.schemaBinding !== undefined && object.schemaBinding !== null)
+            ? SchemaBinding.fromPartial(object.schemaBinding)
+            : undefined;
         return message;
     },
 };
@@ -670,7 +693,7 @@ export const FiberCommit = {
     },
 };
 function createBaseOnChainState() {
-    return { fiberCommits: {}, latestLogs: {} };
+    return { fiberCommits: {}, latestLogs: {}, registryCommits: {} };
 }
 export const OnChainState = {
     encode(message, writer = new BinaryWriter()) {
@@ -680,6 +703,9 @@ export const OnChainState = {
         globalThis.Object.entries(message.latestLogs).forEach(([key, value]) => {
             OnChainState_LatestLogsEntry.encode({ key: key, value }, writer.uint32(18).fork()).join();
         });
+        globalThis.Object.entries(message.registryCommits).forEach(([key, value]) => {
+            OnChainState_RegistryCommitsEntry.encode({ key: key, value }, writer.uint32(26).fork()).join();
+        });
         return writer;
     },
     decode(input, length) {
@@ -709,6 +735,16 @@ export const OnChainState = {
                     }
                     continue;
                 }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    const entry3 = OnChainState_RegistryCommitsEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.registryCommits[entry3.key] = entry3.value;
+                    }
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -741,6 +777,17 @@ export const OnChainState = {
                         return acc;
                     }, {})
                     : {},
+            registryCommits: isObject(object.registryCommits)
+                ? globalThis.Object.entries(object.registryCommits).reduce((acc, [key, value]) => {
+                    acc[key] = globalThis.String(value);
+                    return acc;
+                }, {})
+                : isObject(object.registry_commits)
+                    ? globalThis.Object.entries(object.registry_commits).reduce((acc, [key, value]) => {
+                        acc[key] = globalThis.String(value);
+                        return acc;
+                    }, {})
+                    : {},
         };
     },
     toJSON(message) {
@@ -763,6 +810,15 @@ export const OnChainState = {
                 });
             }
         }
+        if (message.registryCommits) {
+            const entries = globalThis.Object.entries(message.registryCommits);
+            if (entries.length > 0) {
+                obj.registryCommits = {};
+                entries.forEach(([k, v]) => {
+                    obj.registryCommits[k] = v;
+                });
+            }
+        }
         return obj;
     },
     create(base) {
@@ -782,6 +838,12 @@ export const OnChainState = {
             }
             return acc;
         }, {});
+        message.registryCommits = globalThis.Object.entries(object.registryCommits ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = globalThis.String(value);
+            }
+            return acc;
+        }, {});
         return message;
     },
 };
@@ -925,6 +987,74 @@ export const OnChainState_LatestLogsEntry = {
         return message;
     },
 };
+function createBaseOnChainState_RegistryCommitsEntry() {
+    return { key: "", value: "" };
+}
+export const OnChainState_RegistryCommitsEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOnChainState_RegistryCommitsEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return OnChainState_RegistryCommitsEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseOnChainState_RegistryCommitsEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
 function createBaseFiberLogEntryList() {
     return { entries: [] };
 }
@@ -981,7 +1111,7 @@ export const FiberLogEntryList = {
     },
 };
 function createBaseCalculatedState() {
-    return { stateMachines: {}, scripts: {} };
+    return { stateMachines: {}, scripts: {}, registryEntries: {}, reverseNames: {} };
 }
 export const CalculatedState = {
     encode(message, writer = new BinaryWriter()) {
@@ -991,6 +1121,12 @@ export const CalculatedState = {
         globalThis.Object.entries(message.scripts).forEach(([key, value]) => {
             CalculatedState_ScriptsEntry.encode({ key: key, value }, writer.uint32(18).fork()).join();
         });
+        globalThis.Object.entries(message.registryEntries).forEach(([key, value]) => {
+            CalculatedState_RegistryEntriesEntry.encode({ key: key, value }, writer.uint32(26).fork()).join();
+        });
+        globalThis.Object.entries(message.reverseNames).forEach(([key, value]) => {
+            CalculatedState_ReverseNamesEntry.encode({ key: key, value }, writer.uint32(34).fork()).join();
+        });
         return writer;
     },
     decode(input, length) {
@@ -1020,6 +1156,26 @@ export const CalculatedState = {
                     }
                     continue;
                 }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    const entry3 = CalculatedState_RegistryEntriesEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.registryEntries[entry3.key] = entry3.value;
+                    }
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    const entry4 = CalculatedState_ReverseNamesEntry.decode(reader, reader.uint32());
+                    if (entry4.value !== undefined) {
+                        message.reverseNames[entry4.key] = entry4.value;
+                    }
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -1047,6 +1203,28 @@ export const CalculatedState = {
                     return acc;
                 }, {})
                 : {},
+            registryEntries: isObject(object.registry)
+                ? globalThis.Object.entries(object.registry).reduce((acc, [key, value]) => {
+                    acc[key] = RegistryEntry.fromJSON(value);
+                    return acc;
+                }, {})
+                : isObject(object.registry_entries)
+                    ? globalThis.Object.entries(object.registry_entries).reduce((acc, [key, value]) => {
+                        acc[key] = RegistryEntry.fromJSON(value);
+                        return acc;
+                    }, {})
+                    : {},
+            reverseNames: isObject(object.reverseNames)
+                ? globalThis.Object.entries(object.reverseNames).reduce((acc, [key, value]) => {
+                    acc[key] = globalThis.String(value);
+                    return acc;
+                }, {})
+                : isObject(object.reverse_names)
+                    ? globalThis.Object.entries(object.reverse_names).reduce((acc, [key, value]) => {
+                        acc[key] = globalThis.String(value);
+                        return acc;
+                    }, {})
+                    : {},
         };
     },
     toJSON(message) {
@@ -1069,6 +1247,24 @@ export const CalculatedState = {
                 });
             }
         }
+        if (message.registryEntries) {
+            const entries = globalThis.Object.entries(message.registryEntries);
+            if (entries.length > 0) {
+                obj.registry = {};
+                entries.forEach(([k, v]) => {
+                    obj.registry[k] = RegistryEntry.toJSON(v);
+                });
+            }
+        }
+        if (message.reverseNames) {
+            const entries = globalThis.Object.entries(message.reverseNames);
+            if (entries.length > 0) {
+                obj.reverseNames = {};
+                entries.forEach(([k, v]) => {
+                    obj.reverseNames[k] = v;
+                });
+            }
+        }
         return obj;
     },
     create(base) {
@@ -1089,6 +1285,19 @@ export const CalculatedState = {
             }
             return acc;
         }, {});
+        message.registryEntries = globalThis.Object.entries(object.registryEntries ?? {})
+            .reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = RegistryEntry.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        message.reverseNames = globalThis.Object.entries(object.reverseNames ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = globalThis.String(value);
+            }
+            return acc;
+        }, {});
         return message;
     },
 };
@@ -1232,6 +1441,144 @@ export const CalculatedState_ScriptsEntry = {
         return message;
     },
 };
+function createBaseCalculatedState_RegistryEntriesEntry() {
+    return { key: "", value: undefined };
+}
+export const CalculatedState_RegistryEntriesEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            RegistryEntry.encode(message.value, writer.uint32(18).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCalculatedState_RegistryEntriesEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = RegistryEntry.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? RegistryEntry.fromJSON(object.value) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== undefined) {
+            obj.value = RegistryEntry.toJSON(message.value);
+        }
+        return obj;
+    },
+    create(base) {
+        return CalculatedState_RegistryEntriesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCalculatedState_RegistryEntriesEntry();
+        message.key = object.key ?? "";
+        message.value = (object.value !== undefined && object.value !== null)
+            ? RegistryEntry.fromPartial(object.value)
+            : undefined;
+        return message;
+    },
+};
+function createBaseCalculatedState_ReverseNamesEntry() {
+    return { key: "", value: "" };
+}
+export const CalculatedState_ReverseNamesEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCalculatedState_ReverseNamesEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return CalculatedState_ReverseNamesEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseCalculatedState_ReverseNamesEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
 function longToNumber(int64) {
     const num = globalThis.Number(int64.toString());
     if (num > globalThis.Number.MAX_SAFE_INTEGER) {

package/dist/esm/index.js

@@ -30,6 +30,8 @@ export * from './types.js';
 export * from './ottochain/transaction.js';
 export { normalizeCreateStateMachine, normalizeTransitionStateMachine, normalizeArchiveStateMachine, normalizeMessage } from './ottochain/normalize.js';
 export { dropNulls } from './ottochain/drop-nulls.js';
+// ─── Genesis manifest exporter (std-app pre-registration content) ─────────────
+export { buildGenesisManifest, GENESIS_MANIFEST_VERSION } from './ottochain/genesis-manifest.js';
 // ─── Generated protobuf types (canonical definitions) ────────────────────────
 export * from './generated/index.js';
 // ─── Custom error classes ─────────────────────────────────────────────────────

package/dist/esm/ottochain/genesis-manifest.js

@@ -0,0 +1,189 @@
+/**
+ * Genesis Manifest Exporter
+ *
+ * The ottochain metagraph can boot from a NON-EMPTY genesis: a set of standard
+ * packages pre-registered in the registry before any user transaction. This SDK
+ * is the source of truth for those std apps (their proto schemas + JSON-Logic
+ * state-machine definitions), so it is also the source of truth for the
+ * *genesis manifest* — the per-app CONTENT the chain needs to pre-register each
+ * package at genesis.
+ *
+ * DESIGN — content, not consensus hashes:
+ * The manifest ships CONTENT only: the `schemaShape` (the typed, proto-faithful
+ * projection of the app's state message) and the `definition` (the JSON-Logic
+ * `StateMachineDefinition`, verbatim — the same object the chain decodes for any
+ * fiber). The CHAIN computes the consensus values itself from this content:
+ *   - `logicHash` = `StateMachineDefinition.computeDigest(definition)`
+ *   - `schemaHash` = commitment over the FileDescriptorSet (off-chain/Bridge)
+ * We deliberately do NOT replicate the chain's canonical hashing here, so there
+ * is ZERO hash-parity risk. No advisory hashes are emitted (see HONESTY notes in
+ * the PR description); add them later only if an off-chain consumer needs them,
+ * clearly marked advisory.
+ *
+ * NAMING — the reserved `std` label:
+ * Each package is named `std.<app>.package`. `RegistryName` reserves the `std`
+ * label in-protocol (`RegistryName.isReserved`), so ordinary user registrations
+ * of `std.*` are rejected — only the privileged genesis path may claim them.
+ * That is exactly the point: users cannot squat the standard names.
+ *
+ * SCHEMA SHAPES — chain-verified ground truth:
+ * The three `stateMessage` shapes are reproduced verbatim from the chain's own
+ * conformance suite (`StandardAppsConformanceSuite`, the `identity` / `proposal`
+ * / `market` `MessageShape` vals), which proves the on-chain shape validator and
+ * the conformance gate accept them. `commands` is left EMPTY for this first cut —
+ * the conformance suite itself models all three apps with `SortedMap.empty`
+ * commands, and the proto `*Request` messages are transaction-layer DTOs that do
+ * not map cleanly onto the universal state machines' free-form JSON-Logic event
+ * payloads. Deriving per-event command shapes is a flagged follow-up.
+ *
+ * The JSON shape emitted here is built to deserialize against the chain's circe
+ * codecs (`SchemaShape` / `FieldShape` / `MessageShape` and
+ * `StateMachineDefinition`), whose magnolia config is camelCase with defaults.
+ *
+ * @packageDocumentation
+ */
+import { identityUniversalDef } from '../apps/identity/state-machines/identity-universal.js';
+import { govUniversalDef } from '../apps/governance/state-machines/governance-universal.js';
+import { marketUniversalDef } from '../apps/markets/state-machines/market-universal.js';
+import { toProtoDefinition } from '../schema/fiber-app.js';
+/** Manifest schema version. Bump on any breaking change to the shape. */
+export const GENESIS_MANIFEST_VERSION = 1;
+// ─── Chain-verified state-message shapes ──────────────────────────────────────
+// Reproduced VERBATIM from ottochain
+// modules/shared-data/.../StandardAppsConformanceSuite.scala — the `identity`,
+// `proposal`, and `market` MessageShape vals. Keep these byte-for-byte in step
+// with that suite; it is what guarantees the chain accepts them.
+/** Helper: a FieldShape with the two boolean defaults made explicit. */
+function field(name, number, typeName, repeated = false, optional = false) {
+    return { name, number, typeName, repeated, optional };
+}
+/** ottochain.apps.identity.v1.Identity */
+const identityStateMessage = {
+    typeName: 'ottochain.apps.identity.v1.Identity',
+    fields: [
+        field('id', 1, 'string'),
+        field('address', 2, 'string'),
+        field('public_key', 3, 'string'),
+        field('display_name', 4, 'string'),
+        field('identity_type', 5, 'ottochain.apps.identity.v1.IdentityType'),
+        field('state', 6, 'ottochain.apps.identity.v1.IdentityState'),
+        field('reputation', 7, 'ottochain.apps.identity.v1.Reputation'),
+        field('stake', 8, 'int64'),
+        field('domains', 9, 'string', true),
+        field('platform_links', 10, 'ottochain.apps.identity.v1.PlatformLink', true),
+        field('penalty_history', 11, 'ottochain.apps.identity.v1.PenaltyEvent', true),
+        field('created_at', 12, 'google.protobuf.Timestamp'),
+        field('updated_at', 13, 'google.protobuf.Timestamp'),
+    ],
+};
+/** ottochain.apps.governance.v1.Proposal */
+const governanceStateMessage = {
+    typeName: 'ottochain.apps.governance.v1.Proposal',
+    fields: [
+        field('id', 1, 'string'),
+        field('title', 2, 'string'),
+        field('description', 3, 'string'),
+        field('action_type', 4, 'string'),
+        field('payload', 5, 'google.protobuf.Struct'),
+        field('proposer', 6, 'string'),
+        field('proposed_at', 7, 'google.protobuf.Timestamp'),
+        field('deadline', 8, 'google.protobuf.Timestamp'),
+        field('queued_at', 9, 'google.protobuf.Timestamp'),
+        field('executable_at', 10, 'google.protobuf.Timestamp'),
+    ],
+};
+/** ottochain.apps.markets.v1.Market */
+const marketStateMessage = {
+    typeName: 'ottochain.apps.markets.v1.Market',
+    fields: [
+        field('id', 1, 'string'),
+        field('market_type', 2, 'ottochain.apps.markets.v1.MarketType'),
+        field('creator', 3, 'string'),
+        field('title', 4, 'string'),
+        field('terms', 5, 'google.protobuf.Struct'),
+        field('deadline', 6, 'google.protobuf.Timestamp'),
+        field('threshold', 7, 'int64'),
+        field('commitments', 8, 'ottochain.apps.markets.v1.Commitment', true),
+        field('oracles', 9, 'string', true),
+        field('quorum', 10, 'int32'),
+        field('resolutions', 11, 'ottochain.apps.markets.v1.Resolution', true),
+        field('status', 12, 'ottochain.apps.markets.v1.MarketState'),
+        field('created_at', 13, 'google.protobuf.Timestamp'),
+        field('updated_at', 14, 'google.protobuf.Timestamp'),
+    ],
+};
+// ─── Definition projection (single source of truth = the exported defs) ───────
+/**
+ * Project a `FiberAppDefinition` into the chain's wire `StateMachineDefinition`,
+ * matching the `json-archive/*.json` convention exactly:
+ *   - states carry explicit `metadata: null`,
+ *   - transitions carry explicit `dependencies: []`,
+ *   - the TypeScript-only `FiberAppMetadata` is stripped (`metadata: null`).
+ *
+ * Built on the shared `toProtoDefinition` projector so the manifest never drifts
+ * from the SDK's own exported app definitions. The chain decodes `dependencies:
+ * []` / `metadata: null` identically to their absent forms (its codecs use
+ * defaults), so this is consensus-equivalent to the archives while staying
+ * byte-identical to the checked-in `json-archive/*.json` files.
+ */
+function toWireDefinition(def) {
+    const proto = toProtoDefinition(def);
+    const states = {};
+    for (const [key, st] of Object.entries(proto.states)) {
+        states[key] = { id: st.id, isFinal: st.isFinal, metadata: null };
+    }
+    return {
+        states,
+        initialState: proto.initialState,
+        transitions: proto.transitions.map((t) => ({
+            from: t.from,
+            to: t.to,
+            eventName: t.eventName,
+            guard: t.guard,
+            effect: t.effect,
+            dependencies: t.dependencies ?? [],
+        })),
+        // Strip FiberAppMetadata — the chain's `metadata` is `Option[JsonLogicValue]`.
+        metadata: null,
+    };
+}
+// ─── Builder ──────────────────────────────────────────────────────────────────
+/**
+ * Assemble the genesis manifest for the standard apps.
+ *
+ * Covers THREE apps in this first cut — identity, governance, markets (all the
+ * `universal` variant). The other std apps (contracts, oracles, corporate) and
+ * non-universal variants are a flagged follow-up.
+ *
+ * @returns a `GenesisManifest` whose JSON deserializes against the chain's circe
+ *   codecs. Hashes are intentionally absent — the chain derives them.
+ */
+export function buildGenesisManifest() {
+    const packages = [
+        {
+            name: 'std.identity.package',
+            semver: '1.0.0',
+            strict: false,
+            metadata: {},
+            schemaShape: { stateMessage: identityStateMessage, commands: {} },
+            definition: toWireDefinition(identityUniversalDef),
+        },
+        {
+            name: 'std.governance.package',
+            semver: '1.0.0',
+            strict: false,
+            metadata: {},
+            schemaShape: { stateMessage: governanceStateMessage, commands: {} },
+            definition: toWireDefinition(govUniversalDef),
+        },
+        {
+            name: 'std.markets.package',
+            semver: '1.0.0',
+            strict: false,
+            metadata: {},
+            schemaShape: { stateMessage: marketStateMessage, commands: {} },
+            definition: toWireDefinition(marketUniversalDef),
+        },
+    ];
+    return { version: GENESIS_MANIFEST_VERSION, packages };
+}