@ottochain/sdk 2.2.5 → 2.4.0

package/dist/types/generated/ottochain/apps/contracts/v1/contract.d.ts

@@ -1,7 +1,7 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 export declare const protobufPackage = "ottochain.apps.contracts.v1";
 /** Contract lifecycle states */
-export declare enum ContractState {
+export declare enum State {
     CONTRACT_STATE_UNSPECIFIED = "CONTRACT_STATE_UNSPECIFIED",
     /** CONTRACT_STATE_PROPOSED - Awaiting counterparty acceptance */
     CONTRACT_STATE_PROPOSED = "CONTRACT_STATE_PROPOSED",
@@ -17,9 +17,9 @@ export declare enum ContractState {
     CONTRACT_STATE_CANCELLED = "CONTRACT_STATE_CANCELLED",
     UNRECOGNIZED = "UNRECOGNIZED"
 }
-export declare function contractStateFromJSON(object: any): ContractState;
-export declare function contractStateToJSON(object: ContractState): string;
-export declare function contractStateToNumber(object: ContractState): number;
+export declare function stateFromJSON(object: any): State;
+export declare function stateToJSON(object: State): string;
+export declare function stateToNumber(object: State): number;
 /** Contract between two agents */
 export interface Contract {
     id: string;
@@ -27,7 +27,7 @@ export interface Contract {
     contractId: string;
     proposer: string;
     counterparty: string;
-    state: ContractState;
+    state: State;
     /** Flexible terms structure */
     terms?: {
         [key: string]: any;

package/dist/types/generated/ottochain/apps/identity/v1/identity.d.ts

@@ -1,7 +1,7 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 export declare const protobufPackage = "ottochain.apps.identity.v1";
 /** Identity type - determines which state machine variant applies */
-export declare enum IdentityType {
+export declare enum Type {
     IDENTITY_TYPE_UNSPECIFIED = "IDENTITY_TYPE_UNSPECIFIED",
     /** IDENTITY_TYPE_AGENT - AI agent identity */
     IDENTITY_TYPE_AGENT = "IDENTITY_TYPE_AGENT",
@@ -11,14 +11,14 @@ export declare enum IdentityType {
     IDENTITY_TYPE_SERVICE = "IDENTITY_TYPE_SERVICE",
     UNRECOGNIZED = "UNRECOGNIZED"
 }
-export declare function identityTypeFromJSON(object: any): IdentityType;
-export declare function identityTypeToJSON(object: IdentityType): string;
-export declare function identityTypeToNumber(object: IdentityType): number;
+export declare function typeFromJSON(object: any): Type;
+export declare function typeToJSON(object: Type): string;
+export declare function typeToNumber(object: Type): number;
 /**
  * Unified identity lifecycle states
  * Shared across all identity types with type-specific transitions
  */
-export declare enum IdentityState {
+export declare enum State {
     IDENTITY_STATE_UNSPECIFIED = "IDENTITY_STATE_UNSPECIFIED",
     /** IDENTITY_STATE_UNREGISTERED - Not yet registered (oracle initial) */
     IDENTITY_STATE_UNREGISTERED = "IDENTITY_STATE_UNREGISTERED",
@@ -40,9 +40,9 @@ export declare enum IdentityState {
     IDENTITY_STATE_WITHDRAWN = "IDENTITY_STATE_WITHDRAWN",
     UNRECOGNIZED = "UNRECOGNIZED"
 }
-export declare function identityStateFromJSON(object: any): IdentityState;
-export declare function identityStateToJSON(object: IdentityState): string;
-export declare function identityStateToNumber(object: IdentityState): number;
+export declare function stateFromJSON(object: any): State;
+export declare function stateToJSON(object: State): string;
+export declare function stateToNumber(object: State): number;
 /** Platform where identity is linked */
 export declare enum Platform {
     PLATFORM_UNSPECIFIED = "PLATFORM_UNSPECIFIED",
@@ -90,8 +90,8 @@ export interface Identity {
     address: string;
     publicKey: string;
     displayName: string;
-    identityType: IdentityType;
-    state: IdentityState;
+    identityType: Type;
+    state: State;
     reputation?: Reputation | undefined;
     /** Staked amount (oracles/services) */
     stake: number;
@@ -103,7 +103,7 @@ export interface Identity {
     updatedAt?: Date | undefined;
 }
 export interface RegisterIdentityRequest {
-    identityType: IdentityType;
+    identityType: Type;
     address: string;
     displayName: string;
     /** For oracles/services */
@@ -137,7 +137,7 @@ export interface WithdrawIdentityRequest {
 }
 export interface IdentityDefinition {
     /** Configuration for identity state machine */
-    identityType: IdentityType;
+    identityType: Type;
     /** Default starting reputation */
     initialReputation: number;
     /** Min rep/stake to activate */

package/dist/types/generated/ottochain/apps/markets/v1/market.d.ts

@@ -1,7 +1,7 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 export declare const protobufPackage = "ottochain.apps.markets.v1";
 /** Type of market mechanism */
-export declare enum MarketType {
+export declare enum Type {
     MARKET_TYPE_UNSPECIFIED = "MARKET_TYPE_UNSPECIFIED",
     /** MARKET_TYPE_PREDICTION - Prediction market for future outcomes */
     MARKET_TYPE_PREDICTION = "MARKET_TYPE_PREDICTION",
@@ -13,11 +13,11 @@ export declare enum MarketType {
     MARKET_TYPE_GROUP_BUY = "MARKET_TYPE_GROUP_BUY",
     UNRECOGNIZED = "UNRECOGNIZED"
 }
-export declare function marketTypeFromJSON(object: any): MarketType;
-export declare function marketTypeToJSON(object: MarketType): string;
-export declare function marketTypeToNumber(object: MarketType): number;
+export declare function typeFromJSON(object: any): Type;
+export declare function typeToJSON(object: Type): string;
+export declare function typeToNumber(object: Type): number;
 /** Market lifecycle states */
-export declare enum MarketState {
+export declare enum State {
     MARKET_STATE_UNSPECIFIED = "MARKET_STATE_UNSPECIFIED",
     /** MARKET_STATE_PROPOSED - Market created, awaiting activation */
     MARKET_STATE_PROPOSED = "MARKET_STATE_PROPOSED",
@@ -35,9 +35,9 @@ export declare enum MarketState {
     MARKET_STATE_CANCELLED = "MARKET_STATE_CANCELLED",
     UNRECOGNIZED = "UNRECOGNIZED"
 }
-export declare function marketStateFromJSON(object: any): MarketState;
-export declare function marketStateToJSON(object: MarketState): string;
-export declare function marketStateToNumber(object: MarketState): number;
+export declare function stateFromJSON(object: any): State;
+export declare function stateToJSON(object: State): string;
+export declare function stateToNumber(object: State): number;
 /** Agent commitment to a market position */
 export interface Commitment {
     /** Committing agent's address */
@@ -67,7 +67,7 @@ export interface Market {
     /** Unique market identifier */
     id: string;
     /** Type of market mechanism */
-    marketType: MarketType;
+    marketType: Type;
     /** Market creator's address */
     creator: string;
     /** Human-readable market title */
@@ -89,7 +89,7 @@ export interface Market {
     /** Oracle resolution submissions */
     resolutions: Resolution[];
     /** Current market state */
-    status: MarketState;
+    status: State;
     /** Market creation timestamp */
     createdAt?: Date | undefined;
     /** Last state update timestamp */
@@ -97,7 +97,7 @@ export interface Market {
 }
 /** Create a new market */
 export interface CreateMarketRequest {
-    marketType: MarketType;
+    marketType: Type;
     creator: string;
     title: string;
     terms?: {

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;