@ottochain/sdk 2.4.0 → 2.6.0

package/dist/esm/templates/machine.js

@@ -0,0 +1,125 @@
+/**
+ * Versioned-machine skeleton + `transition()` / `effect()` composition (handoff §1.2).
+ *
+ * Two moves:
+ *   1. `transition()` / `effect()` build the wire `Transition` + its flat effect map from typed
+ *      fragments instead of a hand-rolled JSON blob.
+ *   2. `machine()` is a versioned-package SKELETON that OWNS exactly ONE canonical wire definition
+ *      (`toProtoDefinition(app)`, computed once) and hands the SAME object to BOTH `publishVersion()`
+ *      and `create()`. That is the verified-binding invariant (F9): because publish and create cannot
+ *      drift, the chain's `definition.computeDigest` equals the registered `logicHash` and the bind
+ *      admits the fiber. The skeleton REUSES `toProtoDefinition` (the one canonicalization path) — it
+ *      never re-derives the wire shape.
+ *
+ * Guardrail (CLAUDE.md #1): every builder here is a pure function emitting the exact wire shape the
+ * chain re-derives. Absent optionals (`metadata`/`participants`/`parentFiberId`/`migration`) are
+ * OMITTED, never `null`; required-no-default fields (`strict` on publish, `dependencies: []` per
+ * transition) are ALWAYS present.
+ */
+import { toProtoDefinition, } from '../schema/fiber-app.js';
+/**
+ * Build a wire {@link Transition} from a typed spec.
+ *
+ *   - `on` → `eventName` (the wire key);
+ *   - `guard` defaults to `{ "==": [1, 1] }`;
+ *   - `dependencies` defaults to `[]` and is ALWAYS present;
+ *   - `effect` is passed through (build it with {@link effect}).
+ *
+ * @example
+ * ```ts
+ * transition({
+ *   from: 'debt_current', to: 'debt_current', on: 'buy',
+ *   effect: effect(
+ *     { status: 'debt_current', purchaseCount: { '+': [{ var: 'state.purchaseCount' }, 1] } },
+ *     triggers([...]), transferAsset([...]),
+ *   ),
+ * });
+ * ```
+ */
+export function transition(t) {
+    return {
+        from: t.from,
+        to: t.to,
+        eventName: t.on,
+        guard: t.guard ?? { '==': [1, 1] },
+        effect: t.effect,
+        dependencies: t.dependencies ?? [],
+    };
+}
+// =============================================================================
+// effect()
+// =============================================================================
+/**
+ * Compose an effect into ONE FLAT map: the state-update fields PLUS any `_`-directive fragments,
+ * all in a single object (`Object.assign({}, stateUpdate, ...directives)`).
+ *
+ * Riverdale effects are flat maps that mix `_`-reserved directives (`_triggers`, `_transferAsset`,
+ * `_spawn`, …) with plain state-update fields — they are NOT `merge`-wrapped. Each directive fragment
+ * is a `Record` (e.g. the output of `transferAsset(...)` / `triggers(...)`), spread in here. Later
+ * fragments override earlier keys (`Object.assign` semantics).
+ *
+ * @example
+ * ```ts
+ * effect(
+ *   { status: 'debt_current', purchaseCount: { '+': [{ var: 'state.purchaseCount' }, 1] } },
+ *   { _triggers: [...] },
+ *   transferAsset([{ assetId: { var: 'event.payAssetId' }, recipient: toFiber({ var: 'event.retailerId' }) }]),
+ * );
+ * // => { status, purchaseCount, _triggers, _transferAsset }
+ * ```
+ */
+export function effect(stateUpdate, ...directives) {
+    return Object.assign({}, stateUpdate, ...directives);
+}
+/** A pinned-Exact `SchemaRef` for `name@version`. Wire: `{ name, version: { Exact: { version } } }`. */
+function exactRef(name, version) {
+    return { name, version: { Exact: { version } } };
+}
+/**
+ * Build a versioned-machine skeleton that binds publish + create to ONE canonical definition.
+ *
+ * The definition is projected ONCE here (`toProtoDefinition(spec.app)`) and the SAME reference is handed
+ * to `wireDefinition()`, `publishVersion().definition`, `create().definition`, and
+ * `upgradeFrom().newDefinition` — so they cannot drift and the chain's verified binding admits the fiber
+ * (F9). REUSES `toProtoDefinition` (the single canonicalization path); never re-derives the wire shape.
+ */
+export function machine(spec) {
+    // Project the canonical wire definition ONCE; every consumer reuses this exact reference.
+    const wireDef = toProtoDefinition(spec.app);
+    return {
+        wireDefinition() {
+            return wireDef;
+        },
+        publishVersion(o) {
+            return {
+                name: spec.name,
+                version: spec.version,
+                // REQUIRED-no-default on the wire; '' is valid empty base64 when no descriptor set is bound.
+                schemaB64: o?.schemaB64 ?? '',
+                machineShape: spec.schemaShape,
+                definition: wireDef, // SAME reference as wireDefinition()/create()
+                strict: o?.strict ?? false, // REQUIRED — never omitted
+                ...(o?.metadata ? { metadata: o.metadata } : {}), // OMIT when absent
+            };
+        },
+        create(o) {
+            return {
+                fiberId: o.fiberId,
+                definition: wireDef, // SAME reference as wireDefinition()/publishVersion()
+                initialData: o.initialData,
+                schemaRef: exactRef(spec.name, spec.version), // verified binding: name@version
+                ...(o.participants ? { participants: o.participants } : {}), // OMIT when absent
+                ...(o.parentFiberId ? { parentFiberId: o.parentFiberId } : {}), // OMIT when absent
+            };
+        },
+        upgradeFrom(o) {
+            return {
+                fiberId: o.fiberId,
+                targetRef: exactRef(spec.name, spec.version),
+                newDefinition: wireDef, // SAME reference — re-pin hashes to the same logicHash
+                targetSequenceNumber: o.targetSequenceNumber,
+                ...(o.migration !== undefined ? { migration: o.migration } : {}), // OMIT (Option) when absent
+            };
+        },
+    };
+}

package/dist/esm/templates/migration.js

@@ -0,0 +1,34 @@
+/**
+ * Migration builders — the `UpgradeFiber.migration` JSON-Logic transform applied on a version upgrade.
+ *
+ * THE FOOT-GUN (F9): a migration's evaluation root is the BARE prior state, not `state.x`.
+ * The chain evaluates the migration expression against `sm.stateData` directly
+ * (`MeteredEvaluator.eval(expr, sm.stateData, Migration)`, FiberEngine.scala:300), so:
+ *   - `{ var: '' }`            => the WHOLE prior state object
+ *   - `{ var: 'loyaltyPoints' }` => the top-level `loyaltyPoints` field
+ * This is UNLIKE an effect, where the root is the transition context and you read `{ var: 'state.x' }`.
+ * Writing `state.loyaltyPoints` in a migration silently reads `undefined`. These helpers hide that
+ * asymmetry by pinning the bare-state root for you.
+ *
+ * `migration` is `Option` on `UpgradeFiber` — when there is no transform, OMIT the key (never send `null`).
+ */
+/**
+ * Seed / overwrite top-level state fields on a version upgrade.
+ * Emits `{ merge: [{ var: '' }, fields] }` — merges `fields` onto the bare prior state, so existing
+ * fields are preserved and the named fields are added or overwritten.
+ *
+ * The `{ var: '' }` root is the BARE prior state (NOT `state.x` like an effect) — that asymmetry is
+ * exactly the F9 foot-gun this helper hides.
+ *
+ * @example seedFields({ loyaltyPoints: 0 }) // => { merge: [{ var: '' }, { loyaltyPoints: 0 }] }
+ */
+export const seedFields = (fields) => ({
+    merge: [{ var: '' }, fields],
+});
+/**
+ * General migration transform with the bare-state root made explicit. `build` receives `{ var: '' }`
+ * (the whole prior state) and returns the migration JSON-Logic.
+ *
+ * @example migration((s) => ({ merge: [s, { x: 1 }] })) // => { merge: [{ var: '' }, { x: 1 }] }
+ */
+export const migration = (build) => build({ var: '' });

package/dist/esm/templates/state-shape.js

@@ -0,0 +1,34 @@
+/**
+ * State-shape-with-defaults — the SDK half of Proposal 01's "declared state shape" (removes F5).
+ *
+ * A declared shape carries a `default` (and optional `type`) per field. It seeds `initialData` so every
+ * accumulator starts at a concrete value — a counter read via `{ '+': [{ var: 'state.x' }, ...] }` never
+ * resolves `null` because `x` was never written. It also yields the set of declared field names for
+ * Proposal 01's var-path checks.
+ */
+/**
+ * Build `initialData` by overlaying `overrides` onto each field's declared `default`.
+ * Every declared field gets a concrete value, so no field reads `null` at runtime. An override for a
+ * field replaces that field's default; overrides for undeclared fields are ignored (only declared fields
+ * are emitted). Determinism: pure function of its inputs, stable key order (declared order).
+ *
+ * @example seedState({ fields: { purchaseCount: { default: 0 }, status: { default: 'ACTIVE' } } })
+ *          // => { purchaseCount: 0, status: 'ACTIVE' }
+ */
+export function seedState(shape, overrides) {
+    const seeded = {};
+    for (const [name, field] of Object.entries(shape.fields)) {
+        seeded[name] =
+            overrides !== undefined && Object.prototype.hasOwnProperty.call(overrides, name)
+                ? overrides[name]
+                : field.default;
+    }
+    return seeded;
+}
+/**
+ * The set of declared state-field names — the fields the effects may read.
+ * Feeds Proposal 01's var-path checks (a `{ var: 'state.foo' }` whose `foo` is not declared is suspect).
+ */
+export function declaredFields(shape) {
+    return new Set(Object.keys(shape.fields));
+}

package/dist/esm/validation.js

@@ -23,9 +23,7 @@ const hexString = (length) => {
 /**
  * Schema for a DAG address
  */
-export const DagAddressSchema = z
-    .string()
-    .regex(/^DAG[0-9][a-zA-Z0-9]{36}$/, 'Must be a valid DAG address');
+export const DagAddressSchema = z.string().regex(/^DAG[0-9][a-zA-Z0-9]{36}$/, 'Must be a valid DAG address');
 // ============================================================================
 // Core Type Schemas
 // ============================================================================

package/dist/esm/zk/index.js

@@ -10,10 +10,10 @@
  * `canonicalForSigning(data)`, so a proof's `exprHash` word equals {@link exprHash}`(rule)` equals a
  * policy's `logicHash` — see {@link proverPreimage} and docs/design/client-side-private-data.md §3.0.
  */
-export { canonicalForSigning, proverPreimage, exprHash, dataHash, KECCAK_TRUE, } from './preimage';
+export { canonicalForSigning, proverPreimage, exprHash, dataHash, KECCAK_TRUE } from './preimage';
 export { R, toFr, frToHex, randomSalt, poseidonCommit, poseidonCommitN, openCommitment, } from './commit';
-export { decodeJlvmPublicValues, } from './types';
-export { groth16Witness, pmtWitness, } from './witness';
-export { ExprRegistry, boundRule, atLeast, atMost, } from './registry';
+export { decodeJlvmPublicValues } from './types';
+export { groth16Witness, pmtWitness } from './witness';
+export { ExprRegistry, boundRule, atLeast, atMost } from './registry';
 export { wordOffset, semiPrivateGuard, verifyGroth16Bundle, checkSemiPrivateBinding, verifySemiPrivate, } from './guard';
 export { SubprocessProver, parseGroth16Stdout, } from './prover';

package/dist/types/apps/compute/index.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Compute Application — bare computation substrates.
+ *
+ * Turing-complete JLVM substrates with no parties, assets, or governance: pure
+ * in-place state evolution. The flagship is `rule110`, an in-place Rule-110
+ * cellular automaton that proves the account layer is Turing-complete.
+ *
+ * @example
+ * ```typescript
+ * import { getComputeDefinition, COMPUTE_DEFINITIONS } from '@ottochain/sdk/apps/compute';
+ *
+ * const rule110Def = getComputeDefinition('rule110');
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { computeRule110Def } from './state-machines/index.js';
+import type { FiberAppDefinition } from '../../schema/fiber-app.js';
+export { computeRule110Def };
+/** All compute (bare-computation) state machine definitions. */
+export declare const COMPUTE_DEFINITIONS: {
+    readonly rule110: {
+        readonly metadata: {
+            readonly name: "ComputeRule110";
+            readonly app: "compute";
+            readonly type: "rule110";
+            readonly version: "1.0.0";
+            readonly description: string;
+        };
+        readonly createSchema: {
+            readonly required: readonly ["tape", "idx"];
+            readonly properties: {
+                readonly tape: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "integer";
+                    };
+                    readonly description: "0/1 CA row (length N).";
+                };
+                readonly idx: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "integer";
+                    };
+                    readonly immutable: true;
+                    readonly description: string;
+                };
+                readonly gen: {
+                    readonly type: "integer";
+                    readonly default: 0;
+                    readonly description: "Generation counter (TM step count).";
+                };
+                readonly maxGen: {
+                    readonly type: "integer";
+                    readonly description: "Optional halt bound; absent ⇒ unbounded.";
+                };
+            };
+        };
+        readonly stateSchema: {
+            readonly properties: {
+                readonly tape: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "integer";
+                    };
+                    readonly computed: true;
+                };
+                readonly idx: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "integer";
+                    };
+                    readonly immutable: true;
+                };
+                readonly gen: {
+                    readonly type: "integer";
+                    readonly computed: true;
+                };
+                readonly maxGen: {
+                    readonly type: "integer";
+                };
+                readonly status: {
+                    readonly type: "string";
+                    readonly computed: true;
+                };
+            };
+        };
+        readonly eventSchemas: {
+            readonly step: {
+                readonly description: "Advance one CA generation in place.";
+            };
+            readonly halt: {
+                readonly description: "Terminate once maxGen is reached (gated by gen >= maxGen).";
+            };
+        };
+        readonly states: {
+            readonly RUNNING: {
+                readonly id: "RUNNING";
+                readonly isFinal: false;
+                readonly metadata: {
+                    readonly label: "Running";
+                    readonly description: "CA evolving; each step = one generation.";
+                    readonly category: "active";
+                };
+            };
+            readonly HALTED: {
+                readonly id: "HALTED";
+                readonly isFinal: true;
+                readonly metadata: {
+                    readonly label: "Halted";
+                    readonly description: "maxGen reached; terminal.";
+                    readonly category: "terminal";
+                };
+            };
+        };
+        readonly initialState: "RUNNING";
+        readonly transitions: readonly [{
+            readonly from: "RUNNING";
+            readonly to: "RUNNING";
+            readonly eventName: "step";
+            readonly guard: {
+                readonly or: readonly [{
+                    readonly missing: readonly ["state.maxGen"];
+                }, {
+                    readonly '<': readonly [{
+                        readonly var: "state.gen";
+                    }, {
+                        readonly var: "state.maxGen";
+                    }];
+                }];
+            };
+            readonly effect: {
+                readonly merge: readonly [{
+                    readonly var: "state";
+                }, {
+                    readonly tape: {
+                        readonly map: readonly [{
+                            readonly var: "state.idx";
+                        }, import("../../schema/fiber-app.js").JsonLogicRule];
+                    };
+                    readonly gen: {
+                        readonly '+': readonly [{
+                            readonly var: "state.gen";
+                        }, 1];
+                    };
+                }];
+            };
+            readonly dependencies: readonly [];
+        }, {
+            readonly from: "RUNNING";
+            readonly to: "HALTED";
+            readonly eventName: "halt";
+            readonly guard: {
+                readonly '>=': readonly [{
+                    readonly var: "state.gen";
+                }, {
+                    readonly var: "state.maxGen";
+                }];
+            };
+            readonly effect: {
+                readonly merge: readonly [{
+                    readonly var: "state";
+                }, {
+                    readonly status: "halted";
+                }];
+            };
+            readonly dependencies: readonly [];
+        }];
+    };
+};
+export type ComputeDefType = keyof typeof COMPUTE_DEFINITIONS;
+/**
+ * Get a compute state machine definition by type.
+ * @param type - 'rule110' (default).
+ */
+export declare function getComputeDefinition(type?: ComputeDefType): FiberAppDefinition;

package/dist/types/apps/compute/state-machines/compute-rule110.d.ts

@@ -0,0 +1,157 @@
+import type { JsonLogicRule } from '../../../schema/fiber-app.js';
+/**
+ * Rule-110 cellular-automaton fiber definition.
+ *
+ * Trust model: PUBLIC / PERMISSIONLESS / pure compute. No assets, no parties,
+ * no owner — anyone may submit `step`. The DoS surface is bounded by per-event
+ * gas/fee (~987 gas/cell) and the optional `maxGen` halt bound (absent ⇒
+ * unbounded; runs until fees stop).
+ */
+export declare const computeRule110Def: {
+    readonly metadata: {
+        readonly name: "ComputeRule110";
+        readonly app: "compute";
+        readonly type: "rule110";
+        readonly version: "1.0.0";
+        readonly description: string;
+    };
+    readonly createSchema: {
+        readonly required: readonly ["tape", "idx"];
+        readonly properties: {
+            readonly tape: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "integer";
+                };
+                readonly description: "0/1 CA row (length N).";
+            };
+            readonly idx: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "integer";
+                };
+                readonly immutable: true;
+                readonly description: string;
+            };
+            readonly gen: {
+                readonly type: "integer";
+                readonly default: 0;
+                readonly description: "Generation counter (TM step count).";
+            };
+            readonly maxGen: {
+                readonly type: "integer";
+                readonly description: "Optional halt bound; absent ⇒ unbounded.";
+            };
+        };
+    };
+    readonly stateSchema: {
+        readonly properties: {
+            readonly tape: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "integer";
+                };
+                readonly computed: true;
+            };
+            readonly idx: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "integer";
+                };
+                readonly immutable: true;
+            };
+            readonly gen: {
+                readonly type: "integer";
+                readonly computed: true;
+            };
+            readonly maxGen: {
+                readonly type: "integer";
+            };
+            readonly status: {
+                readonly type: "string";
+                readonly computed: true;
+            };
+        };
+    };
+    readonly eventSchemas: {
+        readonly step: {
+            readonly description: "Advance one CA generation in place.";
+        };
+        readonly halt: {
+            readonly description: "Terminate once maxGen is reached (gated by gen >= maxGen).";
+        };
+    };
+    readonly states: {
+        readonly RUNNING: {
+            readonly id: "RUNNING";
+            readonly isFinal: false;
+            readonly metadata: {
+                readonly label: "Running";
+                readonly description: "CA evolving; each step = one generation.";
+                readonly category: "active";
+            };
+        };
+        readonly HALTED: {
+            readonly id: "HALTED";
+            readonly isFinal: true;
+            readonly metadata: {
+                readonly label: "Halted";
+                readonly description: "maxGen reached; terminal.";
+                readonly category: "terminal";
+            };
+        };
+    };
+    readonly initialState: "RUNNING";
+    readonly transitions: readonly [{
+        readonly from: "RUNNING";
+        readonly to: "RUNNING";
+        readonly eventName: "step";
+        readonly guard: {
+            readonly or: readonly [{
+                readonly missing: readonly ["state.maxGen"];
+            }, {
+                readonly '<': readonly [{
+                    readonly var: "state.gen";
+                }, {
+                    readonly var: "state.maxGen";
+                }];
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly tape: {
+                    readonly map: readonly [{
+                        readonly var: "state.idx";
+                    }, JsonLogicRule];
+                };
+                readonly gen: {
+                    readonly '+': readonly [{
+                        readonly var: "state.gen";
+                    }, 1];
+                };
+            }];
+        };
+        readonly dependencies: readonly [];
+    }, {
+        readonly from: "RUNNING";
+        readonly to: "HALTED";
+        readonly eventName: "halt";
+        readonly guard: {
+            readonly '>=': readonly [{
+                readonly var: "state.gen";
+            }, {
+                readonly var: "state.maxGen";
+            }];
+        };
+        readonly effect: {
+            readonly merge: readonly [{
+                readonly var: "state";
+            }, {
+                readonly status: "halted";
+            }];
+        };
+        readonly dependencies: readonly [];
+    }];
+};

package/dist/types/apps/compute/state-machines/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compute (bare-computation) state machine definitions.
+ * Re-exports from TypeScript definition files.
+ */
+export { computeRule110Def } from './compute-rule110.js';

package/dist/types/apps/contracts/index.d.ts

@@ -18,10 +18,10 @@
  *
  * @packageDocumentation
  */
-export { State, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, stateFromJSON, stateToJSON, } from "../../generated/ottochain/apps/contracts/v1/contract.js";
-export { State as ContractState, stateFromJSON as contractStateFromJSON, stateToJSON as contractStateToJSON, } from "../../generated/ottochain/apps/contracts/v1/contract.js";
-import { contractUniversalDef, contractAgreementDef, contractEscrowDef } from "./state-machines/index.js";
-import type { FiberAppDefinition } from "../../schema/fiber-app.js";
+export { State, Contract, ProposeContractRequest, AcceptContractRequest, CompleteContractRequest, RejectContractRequest, DisputeContractRequest, ContractDefinition, stateFromJSON, stateToJSON, } from '../../generated/ottochain/apps/contracts/v1/contract.js';
+export { State as ContractState, stateFromJSON as contractStateFromJSON, stateToJSON as contractStateToJSON, } from '../../generated/ottochain/apps/contracts/v1/contract.js';
+import { contractUniversalDef, contractAgreementDef, contractEscrowDef } from './state-machines/index.js';
+import type { FiberAppDefinition } from '../../schema/fiber-app.js';
 export { contractUniversalDef, contractAgreementDef, contractEscrowDef };
 /** All contract state machine definitions */
 export declare const CONTRACTS_DEFINITIONS: {
@@ -104,7 +104,7 @@ export declare const CONTRACTS_DEFINITIONS: {
             to: "ACTIVE";
             eventName: "accept";
             guard: {
-                "==": number[];
+                '==': number[];
             };
             effect: {
                 merge: ({
@@ -125,7 +125,7 @@ export declare const CONTRACTS_DEFINITIONS: {
             to: "CANCELLED";
             eventName: "cancel";
             guard: {
-                "==": number[];
+                '==': number[];
             };
             effect: {
                 merge: ({
@@ -146,7 +146,7 @@ export declare const CONTRACTS_DEFINITIONS: {
             to: "COMPLETED";
             eventName: "complete";
             guard: {
-                "==": number[];
+                '==': number[];
             };
             effect: {
                 merge: ({
@@ -167,7 +167,7 @@ export declare const CONTRACTS_DEFINITIONS: {
             to: "CANCELLED";
             eventName: "cancel";
             guard: {
-                "==": number[];
+                '==': number[];
             };
             effect: {
                 merge: ({
@@ -460,7 +460,7 @@ export declare const CONTRACTS_DEFINITIONS: {
             eventName: "submit_completion";
             guard: {
                 and: import("../../index.js").GuardRule[];
-                ">="?: undefined;
+                '>='?: undefined;
                 or?: undefined;
             };
             effect: {
@@ -492,7 +492,7 @@ export declare const CONTRACTS_DEFINITIONS: {
             to: "COMPLETED";
             eventName: "finalize";
             guard: {
-                ">=": (number | {
+                '>=': (number | {
                     length: {
                         var: string;
                     }[];
@@ -548,7 +548,7 @@ export declare const CONTRACTS_DEFINITIONS: {
             guard: {
                 or: import("../../index.js").GuardRule[];
                 and?: undefined;
-                ">="?: undefined;
+                '>='?: undefined;
             };
             effect: {
                 merge: ({
@@ -918,7 +918,7 @@ export declare const CONTRACTS_DEFINITIONS: {
                         };
                     };
                     releaseDeadline: {
-                        "+": {
+                        '+': {
                             var: string;
                         }[];
                     };
@@ -1027,9 +1027,9 @@ export declare const CONTRACTS_DEFINITIONS: {
             guard: {
                 or: ({
                     and: import("../../index.js").GuardRule[];
-                    ">="?: undefined;
+                    '>='?: undefined;
                 } | {
-                    ">=": {
+                    '>=': {
                         var: string;
                     }[];
                     and?: undefined;