@ottochain/sdk 2.2.5 → 2.3.0

package/dist/types/generated/ottochain/v1/common.d.ts

@@ -1 +1,229 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 export declare const protobufPackage = "ottochain.v1";
+/**
+ * Lifecycle status of a registered version (npm/Cargo-style).
+ *   - ACTIVE     — selectable + recommended.
+ *   - DEPRECATED — still resolvable/runnable, flagged, discouraged for new instances.
+ *   - YANKED     — excluded from NEW resolutions; existing pinned fibers keep running.
+ */
+export declare enum RegistryStatus {
+    REGISTRY_STATUS_UNSPECIFIED = "REGISTRY_STATUS_UNSPECIFIED",
+    ACTIVE = "ACTIVE",
+    DEPRECATED = "DEPRECATED",
+    YANKED = "YANKED",
+    UNRECOGNIZED = "UNRECOGNIZED"
+}
+export declare function registryStatusFromJSON(object: any): RegistryStatus;
+export declare function registryStatusToJSON(object: RegistryStatus): string;
+export declare function registryStatusToNumber(object: RegistryStatus): number;
+/**
+ * A caller's version requirement, resolved against a VersionLineage (Cargo/npm-style).
+ * On the JSON wire it is a single-key wrapper object: {"Exact":{"version":"1.0.0"}}, {"Latest":{}}, ...
+ */
+export interface VersionReq {
+    requirement?: //
+    /** exactly this version */
+    {
+        $case: "exact";
+        exact: ExactVersion;
+    } | //
+    /** same MAJOR and >= v (^1.2.0) */
+    {
+        $case: "caret";
+        caret: CaretVersion;
+    } | //
+    /** same MAJOR.MINOR and >= v (~1.2.0) */
+    {
+        $case: "tilde";
+        tilde: TildeVersion;
+    } | //
+    /** highest selectable version */
+    {
+        $case: "latest";
+        latest: LatestVersion;
+    } | //
+    /** exact artifact by schema hash */
+    {
+        $case: "pinnedHash";
+        pinnedHash: PinnedHashVersion;
+    } | undefined;
+}
+export interface ExactVersion {
+    /** SemVer string */
+    version: string;
+}
+export interface CaretVersion {
+    /** SemVer string */
+    version: string;
+}
+export interface TildeVersion {
+    /** SemVer string */
+    version: string;
+}
+export interface LatestVersion {
+}
+export interface PinnedHashVersion {
+    /** Hash value */
+    schemaHash: string;
+}
+/** A caller's reference to a registered schema/program version, supplied at fiber creation. */
+export interface SchemaRef {
+    /** Full registry name "labels.tld" (e.g. "counter.package") */
+    name: string;
+    version?: VersionReq | undefined;
+}
+/** One field of a MessageShape — mirrors a protobuf FieldDescriptorProto at the field level. */
+export interface FieldShape {
+    name: string;
+    number: number;
+    typeName: string;
+    /** default false */
+    repeated: boolean;
+    /** default false */
+    optional: boolean;
+}
+/** A single protobuf message shape: its type name plus its fields. */
+export interface MessageShape {
+    typeName: string;
+    fields: FieldShape[];
+}
+/**
+ * The on-chain projection of a version's proto schema: the State message plus one
+ * message per command/event (keyed by event name). Publisher-claimed and advisory.
+ */
+export interface SchemaShape {
+    stateMessage?: MessageShape | undefined;
+    /** keyed by event name */
+    commands: {
+        [key: string]: MessageShape;
+    };
+}
+export interface SchemaShape_CommandsEntry {
+    key: string;
+    value?: MessageShape | undefined;
+}
+/**
+ * The resolved, pinned binding recorded on a fiber: which registry (name, version) it
+ * instantiates, with the committed hashes.
+ */
+export interface SchemaBinding {
+    /** Full registry name "labels.tld" */
+    name: string;
+    /** SemVer string */
+    version: string;
+    /** Hash value (descriptor commitment) */
+    schemaHash: string;
+    /** Hash value (verified-binding anchor) */
+    logicHash: string;
+}
+/** One immutable version of a registry entry. */
+export interface RegisteredVersion {
+    /** SemVer string */
+    version: string;
+    /** Hash value (descriptor commitment) */
+    schemaHash: string;
+    /** Hash value (verified-binding anchor) */
+    logicHash: string;
+    schemaShape?: SchemaShape | undefined;
+    status: RegistryStatus;
+    /** Snapshot ordinal */
+    registeredAt: number;
+    /** default false */
+    strict: boolean;
+}
+/** The append-only, monotonic version lineage of a single registry entry. */
+export interface VersionLineage {
+    /** SemVer-string keyed */
+    versions: {
+        [key: string]: RegisteredVersion;
+    };
+}
+export interface VersionLineage_VersionsEntry {
+    key: string;
+    value?: RegisteredVersion | undefined;
+}
+/**
+ * What a registry entry resolves to, discriminated by the name's TLD.
+ * On the JSON wire it is a single-key wrapper object. Note the SchemaPackage double-nesting:
+ * {"SchemaPackage":{"versions":{"versions":{"1.0.0":{...}}}}}.
+ */
+export interface RegistryTarget {
+    target?: //
+    /** .package — a versioned schema/program type */
+    {
+        $case: "schemaPackage";
+        schemaPackage: SchemaPackageTarget;
+    } | //
+    /** .machine / .script — a nickname for a fiber (#29) */
+    {
+        $case: "instanceAlias";
+        instanceAlias: InstanceAliasTarget;
+    } | undefined;
+}
+export interface SchemaPackageTarget {
+    versions?: VersionLineage | undefined;
+}
+export interface InstanceAliasTarget {
+    fiberId: string;
+}
+/** A single owned entry in the registry namespace. */
+export interface RegistryEntry {
+    /** Full registry name "labels.tld" */
+    name: string;
+    /** Owning DAG addresses */
+    owner: string[];
+    target?: RegistryTarget | undefined;
+    /** Optional off-chain links grab-bag */
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface RegistryEntry_MetadataEntry {
+    key: string;
+    value: string;
+}
+export declare const VersionReq: MessageFns<VersionReq>;
+export declare const ExactVersion: MessageFns<ExactVersion>;
+export declare const CaretVersion: MessageFns<CaretVersion>;
+export declare const TildeVersion: MessageFns<TildeVersion>;
+export declare const LatestVersion: MessageFns<LatestVersion>;
+export declare const PinnedHashVersion: MessageFns<PinnedHashVersion>;
+export declare const SchemaRef: MessageFns<SchemaRef>;
+export declare const FieldShape: MessageFns<FieldShape>;
+export declare const MessageShape: MessageFns<MessageShape>;
+export declare const SchemaShape: MessageFns<SchemaShape>;
+export declare const SchemaShape_CommandsEntry: MessageFns<SchemaShape_CommandsEntry>;
+export declare const SchemaBinding: MessageFns<SchemaBinding>;
+export declare const RegisteredVersion: MessageFns<RegisteredVersion>;
+export declare const VersionLineage: MessageFns<VersionLineage>;
+export declare const VersionLineage_VersionsEntry: MessageFns<VersionLineage_VersionsEntry>;
+export declare const RegistryTarget: MessageFns<RegistryTarget>;
+export declare const SchemaPackageTarget: MessageFns<SchemaPackageTarget>;
+export declare const InstanceAliasTarget: MessageFns<InstanceAliasTarget>;
+export declare const RegistryEntry: MessageFns<RegistryEntry>;
+export declare const RegistryEntry_MetadataEntry: MessageFns<RegistryEntry_MetadataEntry>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/types/generated/ottochain/v1/fiber.d.ts

@@ -1,4 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { SchemaBinding } from "./common.js";
 export declare const protobufPackage = "ottochain.v1";
 /** Fiber lifecycle status */
 export declare enum FiberStatus {
@@ -84,7 +85,29 @@ export interface ScriptInvocation {
     /** DAG address */
     invokedBy: string;
 }
-/** Fiber log entry - union of event receipt or script invocation */
+/** Creation receipt - birth record for a fiber, emitted once at creation (#26/#30) */
+export interface CreationReceipt {
+    fiberId: string;
+    /** Snapshot ordinal */
+    ordinal: number;
+    /** State ID */
+    initialState: string;
+    /** DAG addresses */
+    owners: string[];
+    schemaBinding?: SchemaBinding | undefined;
+    parentFiberId?: string | undefined;
+}
+/** Upgrade receipt - emitted when a fiber is upgraded to a different registered version (#27) */
+export interface UpgradeReceipt {
+    fiberId: string;
+    /** Snapshot ordinal */
+    ordinal: number;
+    fromBinding?: SchemaBinding | undefined;
+    toBinding?: SchemaBinding | undefined;
+    gasUsed: number;
+    migrated: boolean;
+}
+/** Fiber log entry - union of event receipt, script invocation, or lifecycle receipt */
 export interface FiberLogEntry {
     entry?: {
         $case: "eventReceipt";
@@ -92,6 +115,12 @@ export interface FiberLogEntry {
     } | {
         $case: "scriptInvocation";
         scriptInvocation: ScriptInvocation;
+    } | {
+        $case: "creationReceipt";
+        creationReceipt: CreationReceipt;
+    } | {
+        $case: "upgradeReceipt";
+        upgradeReceipt: UpgradeReceipt;
     } | undefined;
 }
 export declare const AccessControlPolicy: MessageFns<AccessControlPolicy>;
@@ -102,6 +131,8 @@ export declare const StateMachineDefinition: MessageFns<StateMachineDefinition>;
 export declare const EmittedEvent: MessageFns<EmittedEvent>;
 export declare const EventReceipt: MessageFns<EventReceipt>;
 export declare const ScriptInvocation: MessageFns<ScriptInvocation>;
+export declare const CreationReceipt: MessageFns<CreationReceipt>;
+export declare const UpgradeReceipt: MessageFns<UpgradeReceipt>;
 export declare const FiberLogEntry: MessageFns<FiberLogEntry>;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {

package/dist/types/generated/ottochain/v1/messages.d.ts

@@ -1,4 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { RegistryStatus, SchemaRef, SchemaShape } from "./common.js";
 import { AccessControlPolicy, StateMachineDefinition } from "./fiber.js";
 export declare const protobufPackage = "ottochain.v1";
 /** Create a new state machine fiber */
@@ -7,6 +8,11 @@ export interface CreateStateMachine {
     definition?: StateMachineDefinition | undefined;
     initialData?: any | undefined;
     parentFiberId?: string | undefined;
+    /**
+     * Optional reference to a registered schema/program version (#26). When present, the chain
+     * resolves it against the registry at create time and records the verified SchemaBinding.
+     */
+    schemaRef?: SchemaRef | undefined;
 }
 /** Trigger a state machine transition */
 export interface TransitionStateMachine {
@@ -22,6 +28,16 @@ export interface ArchiveStateMachine {
     /** Fiber ordinal */
     targetSequenceNumber: number;
 }
+/** Upgrade an existing fiber to a different registered version of the SAME package (#27). */
+export interface UpgradeFiber {
+    fiberId: string;
+    targetRef?: SchemaRef | undefined;
+    newDefinition?: StateMachineDefinition | undefined;
+    /** Optional JSON-Logic transform applied to the prior state data during upgrade. */
+    migration?: any | undefined;
+    /** Fiber ordinal */
+    targetSequenceNumber: number;
+}
 /** Create a new script fiber */
 export interface CreateScript {
     fiberId: string;
@@ -37,6 +53,56 @@ export interface InvokeScript {
     /** Fiber ordinal */
     targetSequenceNumber: number;
 }
+/**
+ * Create-or-append a registry schema-package version (npm-publish semantics). The chain derives
+ * the routing id from `name`, so there is no fiber_id on the wire.
+ */
+export interface PublishVersion {
+    /** Full registry name "labels.tld" (e.g. "order.package") */
+    name: string;
+    /** SemVer string "MAJOR.MINOR.PATCH" */
+    version: string;
+    /** Base64 of the proto FileDescriptorSet (base64-validated + hashed, then dropped) */
+    schemaB64: string;
+    schemaShape?: SchemaShape | undefined;
+    definition?: StateMachineDefinition | undefined;
+    /** Opt-in runtime conformance gate (#33); default false */
+    strict: boolean;
+    /** Optional off-chain links grab-bag */
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface PublishVersion_MetadataEntry {
+    key: string;
+    value: string;
+}
+/** Change a registered version's lifecycle status (Active <-> Deprecated -> Yanked). Owner-gated. */
+export interface SetVersionStatus {
+    /** Full registry name "labels.tld" */
+    name: string;
+    /** SemVer string */
+    version: string;
+    status: RegistryStatus;
+}
+/**
+ * Register a human-readable nickname for an existing fiber (#29). The chain derives the routing id
+ * from `name`, so there is no fiber_id on the wire.
+ */
+export interface RegisterAlias {
+    /** Full registry name "labels.tld" (e.g. "my-escrow.machine") */
+    name: string;
+    /** The existing fiber UUID this alias points at */
+    targetFiberId: string;
+    /** Optional off-chain links grab-bag */
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface RegisterAlias_MetadataEntry {
+    key: string;
+    value: string;
+}
 /** Union message type for all OttoChain operations */
 export interface OttochainMessage {
     message?: {
@@ -54,13 +120,31 @@ export interface OttochainMessage {
     } | {
         $case: "invokeScript";
         invokeScript: InvokeScript;
+    } | {
+        $case: "upgradeFiber";
+        upgradeFiber: UpgradeFiber;
+    } | {
+        $case: "publishVersion";
+        publishVersion: PublishVersion;
+    } | {
+        $case: "setVersionStatus";
+        setVersionStatus: SetVersionStatus;
+    } | {
+        $case: "registerAlias";
+        registerAlias: RegisterAlias;
     } | undefined;
 }
 export declare const CreateStateMachine: MessageFns<CreateStateMachine>;
 export declare const TransitionStateMachine: MessageFns<TransitionStateMachine>;
 export declare const ArchiveStateMachine: MessageFns<ArchiveStateMachine>;
+export declare const UpgradeFiber: MessageFns<UpgradeFiber>;
 export declare const CreateScript: MessageFns<CreateScript>;
 export declare const InvokeScript: MessageFns<InvokeScript>;
+export declare const PublishVersion: MessageFns<PublishVersion>;
+export declare const PublishVersion_MetadataEntry: MessageFns<PublishVersion_MetadataEntry>;
+export declare const SetVersionStatus: MessageFns<SetVersionStatus>;
+export declare const RegisterAlias: MessageFns<RegisterAlias>;
+export declare const RegisterAlias_MetadataEntry: MessageFns<RegisterAlias_MetadataEntry>;
 export declare const OttochainMessage: MessageFns<OttochainMessage>;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {

package/dist/types/generated/ottochain/v1/records.d.ts

@@ -1,4 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { RegistryEntry, SchemaBinding } from "./common.js";
 import { AccessControlPolicy, EventReceipt, FiberLogEntry, FiberStatus, ScriptInvocation, StateMachineDefinition } from "./fiber.js";
 export declare const protobufPackage = "ottochain.v1";
 /** State machine fiber record - on-chain representation */
@@ -24,6 +25,8 @@ export interface StateMachineFiberRecord {
     lastReceipt?: EventReceipt | undefined;
     parentFiberId?: string | undefined;
     childFiberIds: string[];
+    /** The resolved, pinned registry binding (#26), present when created from a registered version. */
+    schemaBinding?: SchemaBinding | undefined;
 }
 /** Script fiber record - on-chain representation */
 export interface ScriptFiberRecord {
@@ -61,6 +64,10 @@ export interface OnChainState {
     latestLogs: {
         [key: string]: FiberLogEntryList;
     };
+    /** Per-registry-entry commitment hash, keyed by full registry name "labels.tld". */
+    registryCommits: {
+        [key: string]: string;
+    };
 }
 export interface OnChainState_FiberCommitsEntry {
     key: string;
@@ -70,6 +77,10 @@ export interface OnChainState_LatestLogsEntry {
     key: string;
     value?: FiberLogEntryList | undefined;
 }
+export interface OnChainState_RegistryCommitsEntry {
+    key: string;
+    value: string;
+}
 /** Helper for map of log entries */
 export interface FiberLogEntryList {
     entries: FiberLogEntry[];
@@ -82,6 +93,18 @@ export interface CalculatedState {
     scripts: {
         [key: string]: ScriptFiberRecord;
     };
+    /**
+     * Registry namespace, keyed by full registry name "labels.tld".
+     * Field is named `registry_entries` to avoid a synthetic map-entry name clash with the
+     * top-level RegistryEntry message; the JSON wire key stays `registry` via json_name.
+     */
+    registryEntries: {
+        [key: string]: RegistryEntry;
+    };
+    /** Reverse records (#29): fiber UUID -> its canonical registered name. */
+    reverseNames: {
+        [key: string]: string;
+    };
 }
 export interface CalculatedState_StateMachinesEntry {
     key: string;
@@ -91,16 +114,27 @@ export interface CalculatedState_ScriptsEntry {
     key: string;
     value?: ScriptFiberRecord | undefined;
 }
+export interface CalculatedState_RegistryEntriesEntry {
+    key: string;
+    value?: RegistryEntry | undefined;
+}
+export interface CalculatedState_ReverseNamesEntry {
+    key: string;
+    value: string;
+}
 export declare const StateMachineFiberRecord: MessageFns<StateMachineFiberRecord>;
 export declare const ScriptFiberRecord: MessageFns<ScriptFiberRecord>;
 export declare const FiberCommit: MessageFns<FiberCommit>;
 export declare const OnChainState: MessageFns<OnChainState>;
 export declare const OnChainState_FiberCommitsEntry: MessageFns<OnChainState_FiberCommitsEntry>;
 export declare const OnChainState_LatestLogsEntry: MessageFns<OnChainState_LatestLogsEntry>;
+export declare const OnChainState_RegistryCommitsEntry: MessageFns<OnChainState_RegistryCommitsEntry>;
 export declare const FiberLogEntryList: MessageFns<FiberLogEntryList>;
 export declare const CalculatedState: MessageFns<CalculatedState>;
 export declare const CalculatedState_StateMachinesEntry: MessageFns<CalculatedState_StateMachinesEntry>;
 export declare const CalculatedState_ScriptsEntry: MessageFns<CalculatedState_ScriptsEntry>;
+export declare const CalculatedState_RegistryEntriesEntry: MessageFns<CalculatedState_RegistryEntriesEntry>;
+export declare const CalculatedState_ReverseNamesEntry: MessageFns<CalculatedState_ReverseNamesEntry>;
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
     $case: string;

package/dist/types/index.d.ts

@@ -24,9 +24,11 @@ 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';
+export { buildGenesisManifest, GENESIS_MANIFEST_VERSION } from './ottochain/genesis-manifest.js';
+export type { GenesisManifest, GenesisPackage, GenesisSchemaShape, GenesisMessageShape, GenesisFieldShape, GenesisStateMachineDefinition, } from './ottochain/index.js';
 export * from './generated/index.js';
 export { OttoChainError, NetworkError, ValidationError, SigningError, TransactionError, ErrorCode, isErrorCode, wrapError, } from './errors.js';
 export { DagAddressSchema, PrivateKeySchema, PublicKeySchema, KeyPairSchema, SignatureProofSchema, SignedSchema, TransactionReferenceSchema, CurrencyTransactionValueSchema, CurrencyTransactionSchema, TransferParamsSchema, AgentIdentityRegistrationSchema, PlatformLinkSchema, ContractTermsSchema, ProposeContractRequestSchema, AcceptContractRequestSchema, CompleteContractRequestSchema, validate, validatePrivateKey, validatePublicKey, validateAddress, validateKeyPair, safeParse, assert, type ValidatedKeyPair, type ValidatedSignatureProof, type ValidatedCurrencyTransaction, type ValidatedTransferParams, type ValidatedAgentIdentityRegistration, type ValidatedPlatformLink, type ValidatedProposeContractRequest, type ValidatedAcceptContractRequest, type ValidatedCompleteContractRequest, } from './validation.js';
 export { MetagraphClient as OttoMetagraphClient } from './ottochain/metagraph-client.js';
 export type { MetagraphClientConfig, Checkpoint, SubscribeOptions, FiberStateCallback, Unsubscribe, } from './ottochain/metagraph-client.js';
-export { toProtoDefinition, defineFiberApp, type ProtoStateMachineDefinition, type FiberAppDefinition, type FiberAppMetadata, type StateDefinition, type Transition, } from './schema/fiber-app.js';
+export { toProtoDefinition, defineFiberApp, type ProtoStateMachineDefinition, type FiberAppDefinition, type FiberAppMetadata, type StateDefinition, type StdStateMetadata, type StateCategory, type Transition, } from './schema/fiber-app.js';

package/dist/types/ottochain/genesis-manifest.d.ts

@@ -0,0 +1,130 @@
+/**
+ * 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
+ */
+/**
+ * One field of a protobuf message, mirroring a `FieldDescriptorProto` at the
+ * field level. Matches the chain's `FieldShape` (camelCase, defaults for
+ * `repeated`/`optional`).
+ */
+export interface FieldShape {
+    name: string;
+    number: number;
+    typeName: string;
+    repeated: boolean;
+    optional: boolean;
+}
+/** A protobuf message projection. Matches the chain's `MessageShape`. */
+export interface MessageShape {
+    typeName: string;
+    fields: FieldShape[];
+}
+/**
+ * The typed, proto-faithful projection of a registered schema. Matches the
+ * chain's `SchemaShape`: the state message plus one message per command/event,
+ * keyed by event name.
+ */
+export interface SchemaShape {
+    stateMessage: MessageShape;
+    commands: Record<string, MessageShape>;
+}
+/**
+ * A JSON-Logic `StateMachineDefinition` as the chain decodes it. Kept as an
+ * opaque JSON object: the chain owns its meaning and its hashing. `from`/`to`
+ * and the `states` keys are bare strings (the chain's `StateId` encodes as a
+ * string); `dependencies` defaults to `[]` and state `metadata` to `null`.
+ */
+export interface StateMachineDefinition {
+    states: Record<string, {
+        id: string;
+        isFinal: boolean;
+        metadata: unknown | null;
+    }>;
+    initialState: string;
+    transitions: Array<{
+        from: string;
+        to: string;
+        eventName: string;
+        guard: unknown;
+        effect: unknown;
+        dependencies: unknown[];
+    }>;
+    metadata: unknown | null;
+}
+/**
+ * One package to pre-register at genesis. This is the genesis INPUT, not the
+ * chain's stored `RegisteredVersion`: it carries CONTENT only and the chain
+ * derives `schemaHash` / `logicHash` from it.
+ */
+export interface GenesisPackage {
+    /** RegistryName `"<labels>.package"`, e.g. `std.identity.package`. */
+    name: string;
+    /** SemVer of this initial version. */
+    semver: string;
+    /** Opt-in runtime conformance gate (`RegisteredVersion.strict`). */
+    strict: boolean;
+    /** Free-form notes map (<=8 entries, key <=32 chars, value <=128 chars). */
+    metadata: Record<string, string>;
+    /** Typed, proto-faithful projection of the app's schema. */
+    schemaShape: SchemaShape;
+    /** The JSON-Logic state-machine definition, verbatim. */
+    definition: StateMachineDefinition;
+}
+/** The full genesis manifest the chain consumes to bootstrap its registry. */
+export interface GenesisManifest {
+    version: number;
+    packages: GenesisPackage[];
+}
+/** Manifest schema version. Bump on any breaking change to the shape. */
+export declare const GENESIS_MANIFEST_VERSION = 1;
+/**
+ * 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 declare function buildGenesisManifest(): GenesisManifest;

package/dist/types/ottochain/index.d.ts

@@ -6,7 +6,7 @@
  * @packageDocumentation
  */
 export * as proto from '../generated/index.js';
-export type { Address, FiberId, StateId, HashValue, FiberOrdinal, SnapshotOrdinal, JsonLogicValue, JsonLogicExpression, FiberStatus, AccessControlPolicy, StateMachineDefinition, EmittedEvent, EventReceipt, OracleInvocation, FiberLogEntry, StateMachineFiberRecord, ScriptFiberRecord, FiberRecord, FiberCommit, OnChain, CalculatedState, CreateStateMachine, TransitionStateMachine, ArchiveStateMachine, CreateScript, InvokeScript, OttochainMessage, OttochainMessageType, } from './types.js';
+export type { Address, FiberId, StateId, HashValue, FiberOrdinal, SnapshotOrdinal, JsonLogicValue, JsonLogicExpression, FiberStatus, AccessControlPolicy, StateMachineDefinition, SemVer, RegistryStatus, VersionReq, SchemaRef, FieldShape, MessageShape, SchemaShape, SchemaBinding, RegisteredVersion, VersionLineage, RegistryTarget, RegistryEntry, EmittedEvent, EventReceipt, OracleInvocation, CreationReceipt, UpgradeReceipt, FiberLogEntry, StateMachineFiberRecord, ScriptFiberRecord, FiberRecord, FiberCommit, OnChain, CalculatedState, CreateStateMachine, TransitionStateMachine, ArchiveStateMachine, UpgradeFiber, CreateScript, InvokeScript, PublishVersion, SetVersionStatus, RegisterAlias, OttochainMessage, OttochainMessageType, } from './types.js';
 export { OTTOCHAIN_MESSAGE_TYPES } from './types.js';
 export type { CurrencySnapshotResponse } from './snapshot.js';
 export { decodeOnChainState, getSnapshotOnChainState, getLatestOnChainState, getLogsForFiber, getEventReceipts, getScriptInvocations, extractOnChainState, } from './snapshot.js';
@@ -16,3 +16,5 @@ export { createTransitionPayload, createArchivePayload, createInvokeScriptPayloa
 export type { CreateStateMachineParams, CreateStateMachineMessage, CreateScriptParams, CreateScriptMessage, DataTransactionRequest, TransitionParams, TransitionStateMachineMessage, ArchiveParams, ArchiveStateMachineMessage, InvokeScriptParams, InvokeScriptMessage, } from './transaction.js';
 export { normalizeCreateStateMachine, normalizeTransitionStateMachine, normalizeArchiveStateMachine, normalizeMessage, } from './normalize.js';
 export { dropNulls } from './drop-nulls.js';
+export { buildGenesisManifest, GENESIS_MANIFEST_VERSION } from './genesis-manifest.js';
+export type { GenesisManifest, GenesisPackage, SchemaShape as GenesisSchemaShape, MessageShape as GenesisMessageShape, FieldShape as GenesisFieldShape, StateMachineDefinition as GenesisStateMachineDefinition, } from './genesis-manifest.js';