@ottochain/sdk 2.2.4 → 2.3.0

package/dist/types/apps/markets/state-machines/market-universal.d.ts

@@ -50,27 +50,47 @@ export declare const marketUniversalDef: {
         readonly PROPOSED: {
             readonly id: "PROPOSED";
             readonly isFinal: false;
-            readonly metadata: null;
+            readonly metadata: {
+                readonly label: "Proposed";
+                readonly description: "Market created but not yet open";
+                readonly category: "initial";
+            };
         };
         readonly OPEN: {
             readonly id: "OPEN";
             readonly isFinal: false;
-            readonly metadata: null;
+            readonly metadata: {
+                readonly label: "Open";
+                readonly description: "Market is open for participation";
+                readonly category: "active";
+            };
         };
         readonly CLOSED: {
             readonly id: "CLOSED";
             readonly isFinal: false;
-            readonly metadata: null;
+            readonly metadata: {
+                readonly label: "Closed";
+                readonly description: "Participation closed; awaiting settlement";
+                readonly category: "pending";
+            };
         };
         readonly SETTLED: {
             readonly id: "SETTLED";
             readonly isFinal: true;
-            readonly metadata: null;
+            readonly metadata: {
+                readonly label: "Settled";
+                readonly description: "Market settled and payouts available (terminal)";
+                readonly category: "terminal";
+            };
         };
         readonly CANCELLED: {
             readonly id: "CANCELLED";
             readonly isFinal: true;
-            readonly metadata: null;
+            readonly metadata: {
+                readonly label: "Cancelled";
+                readonly description: "Market cancelled before settlement (terminal)";
+                readonly category: "terminal";
+            };
         };
     };
     readonly initialState: "PROPOSED";

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';