@maelstrom-co/react 0.0.0-stage → 0.1.1

package/dist/lib/maelstrom-instance-types.d.ts

@@ -0,0 +1,228 @@
+import { VesselDefinition } from '@maelstrom-co/protocol';
+import { ComponentType } from 'react';
+import { ChartProps } from './chart/chart.js';
+import { DynamicVesselHandle, UntypedVesselProps } from './dynamic-vessel-types.js';
+import { ExtensionOutput, MaelstromExtension } from './extension-types.js';
+import { MaelstromState } from './maelstrom-state-types.js';
+import { MaelstromProviderProps } from './provider.js';
+import { ActionRunnerLookup, AnyVesselEntry, ExtractVesselByIdFromEntries, TypedVesselProps, UpdateVesselPayload, UpdateVesselResult, VesselIds } from './vessel-entry-types.js';
+/**
+ * Reserved keys on the core instance shape. Extensions are forbidden from
+ * defining keys with these names so `.with()` cannot silently overwrite
+ * `Provider`, `Chart`, the hook surface, etc.
+ */
+export type ReservedInstanceKeys = 'vessels' | 'Provider' | 'Chart' | 'useMaelstrom' | 'useVessel' | 'useActions' | 'useInstance' | 'registerVessel' | 'updateVessel' | 'with';
+/**
+ * Branded compile-time guard: when an extension's return type contains any
+ * `ReservedInstanceKeys`, the `with()` argument type narrows to this error
+ * literal so the call no longer accepts the offending extension function.
+ */
+type ExtensionRejectsReserved<NewExt extends ExtensionOutput> = Extract<keyof NewExt, ReservedInstanceKeys> extends never ? MaelstromExtension<NewExt> : `Error: extension cannot define reserved Maelstrom key '${Extract<keyof NewExt & ReservedInstanceKeys, string>}'`;
+/**
+ * Core Maelstrom instance fields. Generic over `Ext` so the recursive
+ * `with()` return type can carry accumulated extensions; the public type
+ * is `MaelstromInstance<T, Ext> = MaelstromInstanceCore<T, Ext> & Ext`,
+ * so extension fields are structurally part of the instance — no
+ * intersection casts needed at the merge site.
+ */
+export interface MaelstromInstanceCore<T extends readonly AnyVesselEntry[], Ext extends ExtensionOutput = object> {
+    vessels: T;
+    Provider: ComponentType<MaelstromProviderProps>;
+    Chart: ComponentType<ChartProps>;
+    /**
+     * Returns reactive Maelstrom state. Call with no args for the full state,
+     * or pass a selector to subscribe to a slice and avoid re-renders when
+     * unrelated fields change. Derived objects are shallow-compared.
+     *
+     * @example
+     * const { processIntent, isProcessing } = m.useMaelstrom();
+     *
+     * @example
+     * const isProcessing = m.useMaelstrom((s) => s.isProcessing);
+     */
+    useMaelstrom: {
+        <TSelected>(selector: (state: MaelstromState) => TSelected): TSelected;
+        (): MaelstromState;
+    };
+    /**
+     * Returns typed vessel props for the given vessel ID and instance ID.
+     * Returns null when the instance doesn't exist or belongs to a different vessel type.
+     *
+     * variantProps is a discriminated union narrowable via `variantProps.variant`.
+     * executeAction triggers an optimistic local variant transition (if transitionsTo is set),
+     * then dispatches to registered action runners via CommandProcessor.
+     *
+     * @example
+     * const props = m.useVessel('calendar', instanceId);
+     * if (!props) return null;
+     * // props.variantProps.variant === 'month' | 'week'
+     */
+    useVessel: <Id extends VesselIds<T>>(vesselId: Id, instanceId: string) => TypedVesselProps<ExtractVesselByIdFromEntries<T, Id>> | null;
+    /**
+     * Registers side-effect handlers for actions dispatched to an instance (both engine-initiated and user-initiated via executeAction).
+     * Automatically unregisters on component unmount.
+     *
+     * Pass a stable runner reference (defined outside the component or wrapped in useMemo)
+     * to prevent unnecessary re-registrations on each render.
+     *
+     * @example
+     * m.useActions('calendar', instanceId, {
+     *   showWeek: () => ok(undefined),
+     * });
+     */
+    useActions: <Id extends VesselIds<T>>(vesselId: Id, instanceId: string, runner: ActionRunnerLookup<T>[Id]) => void;
+    /**
+     * Untyped escape hatch — returns props for any instance regardless of vessel type.
+     * Works for both statically and dynamically registered vessels.
+     * variantProps is `Record<string, unknown>` and action names are `string`.
+     *
+     * @example
+     * const props = m.useInstance(instanceId);
+     * if (!props) return null;
+     * // props.vesselId tells you which vessel this is
+     */
+    useInstance: (instanceId: string) => UntypedVesselProps | null;
+    /**
+     * Dynamically register a vessel at runtime. Returns a typed handle with
+     * scoped `useVessel`, `useActions`, `update()`, and `unregister()`.
+     * Throws if the vessel fails validation.
+     *
+     * Must be called while a Provider is mounted. The vessel becomes available
+     * for subsequent engine decisions (processIntent calls).
+     *
+     * @example
+     * const handle = m.registerVessel(widgetEntry);
+     * // In component:
+     * const props = handle.useVessel(instanceId);
+     * // Cleanup:
+     * handle.unregister();
+     */
+    registerVessel: <V extends VesselDefinition>(entry: AnyVesselEntry<V>) => DynamicVesselHandle<V>;
+    /**
+     * Republish a registered vessel's definition — its description, variants,
+     * and action parameters — without touching its component registration.
+     *
+     * Use this to keep the LLM-facing contract in sync with live data, e.g.
+     * re-declaring an action parameter's `enum` as the underlying list changes.
+     * Unlike `registerVessel`, this never re-wraps the component, so the vessel
+     * does not remount and keeps any DOM/canvas state it owns.
+     *
+     * `updateVessel` replaces the definition wholesale — it does not merge —
+     * so a rebuild that keeps only the variant or action being edited silently
+     * drops every other one, and reports a conflict if any live instance's
+     * current variant is missing from the rebuild. Map over every variant and
+     * every action instead, as below, so nothing but the targeted parameter
+     * changes.
+     *
+     * For a vessel id declared in `createMaelstrom({ vessels })`, every
+     * variant's `props` must match the shape of some variant on that
+     * vessel's factory-declared entry — the entry passed to
+     * `createMaelstrom({ vessels })`, fixed at compile time — which is what
+     * stops a rebuild from silently handing a mounted component a
+     * `variantProps` object missing a field it destructures. That check is
+     * per-vessel, not per-variant-key: it does not catch swapping two
+     * variants' `props` shapes with each other. `actions`, `enum` values,
+     * `description`, and `minSize` are not checked and stay free to change;
+     * that is exactly the workflow the example below relies on.
+     *
+     * For a vessel id registered only at runtime via `registerVessel()`, `Id`
+     * is outside `VesselIds<T>` and this function cannot name it — call
+     * `update()` on the handle `registerVessel()` returns instead. That
+     * handle is typed to its own inferred vessel definition, so it gets the
+     * same `props`-shape check as above, just checked against the handle's
+     * `V` rather than a factory-declared entry.
+     *
+     * The republish is lazy: it updates the local store immediately, but
+     * nothing schedules a fresh engine request on its own. The engine keeps
+     * working from the previous definition until some other event sends a
+     * request — an intent, an action, a resize. If the change raises a
+     * variant's `minSize`, live tiles on that variant also keep their old
+     * rect until then.
+     *
+     * @returns `{ ok: true }` once the definition is committed. `{ ok: false,
+     * conflict }` when the republish was refused for a recoverable,
+     * user-triggerable reason — not a bug — and the previous definition
+     * stays in force: `conflict.code === 'variant_dropped'` means a live
+     * instance's current variant is absent from the new definition;
+     * `'action_dropped'` means the new definition drops an action the
+     * current definition declares on that instance's variant (for example a
+     * `detail` variant that only exists while its record does, and the user
+     * just deleted that record); `'batch_in_flight'` means a command batch
+     * was already queued or executing, so the instance snapshot this check
+     * would scan cannot be trusted yet — retry once it settles. The
+     * variant/action scan covers every instance in the command-processor
+     * store, including instances not currently rendered as a tile. Branch on
+     * `conflict.code`, not on `conflict.message` text, which this package is
+     * free to reword.
+     *
+     * @throws `Error` if no Provider is mounted, if the vessel id is not
+     * already registered, or if the definition fails validation — those are
+     * caller mistakes, not recoverable states.
+     *
+     * @example
+     * const titles = ['Sprint kickoff', 'Architecture review'];
+     * const result = m.updateVessel({
+     *   ...journalVessel,
+     *   variants: Object.fromEntries(
+     *     Object.entries(journalVessel.variants).map(([variantName, variant]) => [
+     *       variantName,
+     *       {
+     *         ...variant,
+     *         actions: variant.actions.map((action) =>
+     *           action.name === 'openEntry' && action.parameters
+     *             ? {
+     *                 ...action,
+     *                 parameters: action.parameters.map((parameter) =>
+     *                   parameter.name === 'title'
+     *                     ? { ...parameter, enum: titles }
+     *                     : parameter,
+     *                 ),
+     *               }
+     *             : action,
+     *         ),
+     *       },
+     *     ]),
+     *   ),
+     * });
+     * if (!result.ok) {
+     *   switch (result.conflict.code) {
+     *     case 'variant_dropped':
+     *     case 'action_dropped':
+     *       // A live instance would be stranded by this republish — skip it,
+     *       // or surface a message and retry once the record exists again.
+     *       break;
+     *     case 'batch_in_flight':
+     *       // A batch was already in flight — retry on the next render.
+     *       break;
+     *   }
+     * }
+     */
+    updateVessel: <Id extends VesselIds<T>>(vessel: UpdateVesselPayload<T, Id>) => UpdateVesselResult;
+    /**
+     * Apply an extension to the instance, returning a new instance with the
+     * extension's fields merged onto the public surface.
+     *
+     * The returned instance is fresh — calling `.with()` does not mutate the
+     * receiver, so branched chains like
+     * `const a = m.with(extA); const b = m.with(extB);` produce independent
+     * instances that do not share each other's extension fields.
+     *
+     * Reserved keys (`vessels`, `Provider`, `Chart`, the hook surface,
+     * `with`) are rejected at compile time. When two extensions in the same
+     * chain define the same custom key, the later wins at runtime and a
+     * one-shot `console.warn` flags the collision.
+     *
+     * @example
+     * const analytics: MaelstromExtension<{ track: (event: string) => void }> = () => ({
+     *   track: (event) => console.log('[analytics]', event),
+     * });
+     *
+     * const m = createMaelstrom({ vessels }).with(analytics);
+     * m.track('app:start');
+     */
+    with<NewExt extends ExtensionOutput>(ext: ExtensionRejectsReserved<NewExt>): MaelstromInstance<T, Ext & NewExt>;
+}
+/** Return type of createMaelstrom() — core fields plus any applied extensions. */
+export type MaelstromInstance<T extends readonly AnyVesselEntry[], Ext extends ExtensionOutput = object> = MaelstromInstanceCore<T, Ext> & Ext;
+export {};
+//# sourceMappingURL=maelstrom-instance-types.d.ts.map

package/dist/lib/maelstrom-instance-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maelstrom-instance-types.d.ts","sourceRoot":"","sources":["../../src/lib/maelstrom-instance-types.ts"],"names":[],"mappings":"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"}

package/dist/lib/maelstrom-state-types.d.ts

@@ -0,0 +1,30 @@
+import { ConnectionStatus, EnqueueIntentOptions, IntentSchedulerState, IntentSubmission } from '@maelstrom-co/client';
+import { MaelstromResponse, SessionId } from '@maelstrom-co/protocol';
+/** Return type of m.useMaelstrom() */
+export interface MaelstromState {
+    /** Send a user intent to the engine. Never rejects — errors surface via lastError. */
+    processIntent: (intent: string) => Promise<void>;
+    /**
+     * Admit immediately to the client-owned FIFO, including while busy. Operational
+     * outcomes resolve on the ticket; they do not update lastError/lastResponse.
+     * Observe it with useIntentSubmission. No retry is performed for unknown work.
+     * A foreign options.scope throws synchronously. Unmounting this hook does not
+     * cancel accepted work; use a client IntentScope for owner-lifetime retirement.
+     */
+    enqueueIntent: (intent: string, options?: EnqueueIntentOptions) => IntentSubmission;
+    /** Shared admission state, including queued voice work and atomic application. */
+    intentScheduler: IntentSchedulerState;
+    /** Current connection status */
+    connectionStatus: ConnectionStatus;
+    /** Last connection error, if connectionStatus is 'error' */
+    connectionError: Error | null;
+    /** Whether a request is currently in flight */
+    isProcessing: boolean;
+    /** Last error from processIntent — auto-clears on next call */
+    lastError: Error | null;
+    /** Last successful engine response — clears when the next call starts */
+    lastResponse: MaelstromResponse | null;
+    /** Current session ID */
+    sessionId: SessionId;
+}
+//# sourceMappingURL=maelstrom-state-types.d.ts.map

package/dist/lib/maelstrom-state-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maelstrom-state-types.d.ts","sourceRoot":"","sources":["../../src/lib/maelstrom-state-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAE3E,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC7B,sFAAsF;IACtF,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD;;;;;;OAMG;IACH,aAAa,EAAE,CACb,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,oBAAoB,KAC3B,gBAAgB,CAAC;IACtB,kFAAkF;IAClF,eAAe,EAAE,oBAAoB,CAAC;IACtC,gCAAgC;IAChC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,4DAA4D;IAC5D,eAAe,EAAE,KAAK,GAAG,IAAI,CAAC;IAC9B,+CAA+C;IAC/C,YAAY,EAAE,OAAO,CAAC;IACtB,+DAA+D;IAC/D,SAAS,EAAE,KAAK,GAAG,IAAI,CAAC;IACxB,yEAAyE;IACzE,YAAY,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACvC,yBAAyB;IACzB,SAAS,EAAE,SAAS,CAAC;CACtB"}

package/dist/lib/provider.d.ts

@@ -0,0 +1,135 @@
+import { EngineConnector, IntentQueueOptions } from '@maelstrom-co/client';
+import { TilingLayout } from '@maelstrom-co/protocol';
+import { ReactNode } from 'react';
+import { ChartMotionConfig } from './chart/motion/motion-config.js';
+import { ConfigOverrides } from './config-types.js';
+import { MaelstromContextPair } from './context.js';
+import { AnyVesselEntry } from './vessel-entry-types.js';
+/**
+ * Props for the Maelstrom Provider component.
+ *
+ * Split by `layoutMode` so the one combination the Orchestrator can only
+ * reject at runtime — a first-screen seed under `layoutMode: 'grid'` — is
+ * unrepresentable in TypeScript rather than a guaranteed construction
+ * failure that typechecks.
+ */
+export type MaelstromProviderProps = TilingProviderProps | GridProviderProps;
+/** Props shared by both `layoutMode` branches. */
+interface MaelstromProviderBaseProps {
+    /**
+     * Engine connector. Changing the identity of this prop swaps the
+     * transport on the live Orchestrator (`Orchestrator.setConnector`) rather
+     * than rebuilding it — the arranged board, vessel registry, and chart
+     * dimensions all survive. Use this for re-auth; it does not start a new
+     * session.
+     */
+    connector: EngineConnector;
+    /**
+     * Session ID for conversation continuity. Auto-generated if omitted.
+     * Captured once on mount — changing it afterwards is ignored (a console
+     * warning says so). To switch sessions, remount the Provider with a new
+     * `key`.
+     */
+    sessionId?: string;
+    /** Grid cell size in pixels. Overrides the factory default. */
+    cellSizePx?: number;
+    /** Tiling layout gap in pixels. Overrides the factory default. */
+    tilingPaddingPx?: number;
+    /** Enable debug logging. Overrides the factory default. */
+    debug?: boolean;
+    /**
+     * Chart motion/choreography settings. Overrides the factory default as a
+     * whole object — when provided, the factory's `motion` is ignored entirely
+     * rather than merged per-field. Pass a stable reference (hoist or memoize
+     * it): a new object identity on every render re-resolves the config and
+     * re-renders all Maelstrom consumers.
+     */
+    motion?: ChartMotionConfig;
+    /**
+     * Mount-time shared FIFO policy, replacing the factory object. Defaults:
+     * 8 pending, 30s wait, 10s disconnected grace, 60s active result deadline.
+     * Invalid limits fail construction. Later changes are ignored; remount with
+     * a new key to change policy. Deadlines do not cancel active work.
+     */
+    intentQueue?: IntentQueueOptions;
+    /**
+     * Called on Orchestrator startup failures, connection failures,
+     * processIntent failures, executeAction failures, and command-processing
+     * failures — both of `CommandProcessor`'s failure events route here:
+     * `processing_error` (a command threw, a refused `set_layout` being the
+     * common case) and `batch_abandoned` (the trailing commands of that
+     * command's atomic batch never ran), the latter wrapped in an error naming
+     * the abandoned command kinds. One failing command inside a batch therefore
+     * calls this twice, once per half of the damage. Errors from `processIntent`
+     * also surface via `useMaelstrom()`; a refused command does not, because it
+     * has no call to attach to.
+     */
+    onError?: (error: Error) => void;
+    children: ReactNode;
+}
+/** Provider props under the default tiling mode, the only seedable one. */
+interface TilingProviderProps extends MaelstromProviderBaseProps {
+    /**
+     * Layout algorithm used by the engine. Changing this pushes the new mode
+     * into the live Orchestrator (`Orchestrator.setLayoutMode`) rather than
+     * rebuilding it. Omitting it after having set it falls back to the
+     * Orchestrator's own default rather than freezing on the last mode.
+     */
+    layoutMode?: 'tiling';
+    /**
+     * Layout applied once when the Provider mounts, before any engine
+     * round-trip — a *proposed* first screen. The engine sees it in the next
+     * chart request and may reshape or drop tiles to fit the real viewport.
+     *
+     * Requires `layoutMode: 'tiling'` (the default): a grid layout can only
+     * reposition instances that already exist (none do at construction), and a
+     * tiling layout mismatches `layoutMode: 'grid'` outright. There is no way
+     * to seed a first screen in grid mode, which is why the two are split
+     * across the prop union; the Orchestrator still throws on the combination
+     * for untyped callers that route around the types.
+     *
+     * Every instance the seed names must resolve against the *static* vessel
+     * list passed to `createMaelstrom`: a `vesselId` that list registers, and
+     * a variant that vessel declares. Vessels registered later through
+     * `m.registerVessel()` or `useVessel` are not eligible — they register
+     * after the Orchestrator has already been built and validated, so a seed
+     * naming one can never resolve. The seed must also carry no duplicate
+     * `instanceId`, and every leaf of `tree` must appear in `instances`.
+     *
+     * The tree is held to the strict spelling of the grammar: no instance may
+     * appear in two leaves (weight the split token instead of repeating it),
+     * and every weight suffix must be well formed. A suffix an engine response
+     * would have repaired — `"V:1,5000"`, `"V:01,1"` — is rejected here rather
+     * than silently rewritten, so an author is never handed geometry they did
+     * not write.
+     *
+     * Validated during construction, and a validation failure is fatal to the
+     * Provider: the error goes to `onError` and `console.error`, but the
+     * Orchestrator is never created and everything under `<MaelstromProvider>`
+     * renders nothing. A seed naming an unregistered vessel id, an undeclared
+     * variant, or any seed under `layoutMode: 'grid'` white-screens the app —
+     * it does not silently fall back to an unseeded boot. Treat `initialLayout`
+     * as configuration to verify at build time, not as a best-effort hint.
+     *
+     * Captured once: changing this prop after mount is ignored (a console
+     * warning says so); remount with a new `key` to seed a different screen.
+     */
+    initialLayout?: TilingLayout;
+}
+/** Provider props under grid mode, where no first screen can be seeded. */
+interface GridProviderProps extends MaelstromProviderBaseProps {
+    /**
+     * Layout algorithm used by the engine — see the tiling branch for how a
+     * change is pushed into the live Orchestrator. Selecting `'grid'` forbids
+     * `initialLayout`.
+     */
+    layoutMode: 'grid';
+    /**
+     * Unavailable under `layoutMode: 'grid'` — see the tiling branch's
+     * `initialLayout` for why a grid board cannot be seeded.
+     */
+    initialLayout?: never;
+}
+export declare function createProvider(contextPair: MaelstromContextPair, vesselEntries: readonly AnyVesselEntry[], factoryConfig: ConfigOverrides): ({ connector, sessionId, layoutMode, cellSizePx, tilingPaddingPx, debug, motion, intentQueue, onError, initialLayout, children, }: MaelstromProviderProps) => import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=provider.d.ts.map

package/dist/lib/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/lib/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAEnB,MAAM,sBAAsB,CAAC;AAM9B,OAAO,KAAK,EAAE,YAAY,EAAY,MAAM,wBAAwB,CAAC;AAErE,OAAO,KAAK,EAAiB,SAAS,EAAE,MAAM,OAAO,CAAC;AAEtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,OAAO,KAAK,EAAE,oBAAoB,EAAyB,MAAM,cAAc,CAAC;AAEhF,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,yBAAyB,CAAC;AAGjC;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG,mBAAmB,GAAG,iBAAiB,CAAC;AAE7E,kDAAkD;AAClD,UAAU,0BAA0B;IAClC;;;;;;OAMG;IACH,SAAS,EAAE,eAAe,CAAC;IAC3B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,2EAA2E;AAC3E,UAAU,mBAAoB,SAAQ,0BAA0B;IAC9D;;;;;OAKG;IACH,UAAU,CAAC,EAAE,QAAQ,CAAC;IACtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,aAAa,CAAC,EAAE,YAAY,CAAC;CAC9B;AAED,2EAA2E;AAC3E,UAAU,iBAAkB,SAAQ,0BAA0B;IAC5D;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,aAAa,CAAC,EAAE,KAAK,CAAC;CACvB;AAED,wBAAgB,cAAc,CAC5B,WAAW,EAAE,oBAAoB,EACjC,aAAa,EAAE,SAAS,cAAc,EAAE,EACxC,aAAa,EAAE,eAAe,IAII,kIAY/B,sBAAsB,wCA0Q1B"}

package/dist/lib/register-vessel.d.ts

@@ -0,0 +1,13 @@
+import { VesselDefinition } from '@maelstrom-co/protocol';
+import { MaelstromContextPair } from './context.js';
+import { DynamicVesselHandle } from './dynamic-vessel-types.js';
+import { AnyVesselEntry } from './vessel-entry-types.js';
+/**
+ * Factory that creates m.registerVessel() bound to a specific Maelstrom context.
+ *
+ * registerVessel is a plain function (not a hook). It reads the current context from a mutable ref
+ * that the Provider keeps in sync. On success it registers the vessel with the orchestrator
+ * and adds the component to the UI registries. Throws if the vessel fails validation.
+ */
+export declare function createRegisterVessel(contextPair: MaelstromContextPair): <V extends VesselDefinition>(entry: AnyVesselEntry<V>) => DynamicVesselHandle<V>;
+//# sourceMappingURL=register-vessel.d.ts.map

package/dist/lib/register-vessel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-vessel.d.ts","sourceRoot":"","sources":["../../src/lib/register-vessel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAY,MAAM,wBAAwB,CAAC;AAIzE,OAAO,KAAK,EAAE,oBAAoB,EAAyB,MAAM,cAAc,CAAC;AAChF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIrE,OAAO,KAAK,EACV,cAAc,EAIf,MAAM,yBAAyB,CAAC;AAIjC;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,oBAAoB,IAIrC,CAAC,SAAS,gBAAgB,EACvD,OAAO,cAAc,CAAC,CAAC,CAAC,KACvB,mBAAmB,CAAC,CAAC,CAAC,CAuF1B"}

package/dist/lib/require-context.d.ts

@@ -0,0 +1,9 @@
+import { MaelstromContextPair, MaelstromContextValue } from './context.js';
+type RequireContextCaller = 'registerVessel' | 'unregister' | 'updateVessel' | 'handle.update';
+/**
+ * Reads the Provider-synced context ref for the non-hook APIs — these call
+ * sites are plain functions, not hooks, and cannot use `useContext`.
+ */
+export declare function requireContext(contextRef: MaelstromContextPair['contextRef'], caller: RequireContextCaller): MaelstromContextValue;
+export {};
+//# sourceMappingURL=require-context.d.ts.map

package/dist/lib/require-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-context.d.ts","sourceRoot":"","sources":["../../src/lib/require-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEhF,KAAK,oBAAoB,GACrB,gBAAgB,GAChB,YAAY,GACZ,cAAc,GACd,eAAe,CAAC;AAEpB;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,oBAAoB,CAAC,YAAY,CAAC,EAC9C,MAAM,EAAE,oBAAoB,GAC3B,qBAAqB,CAQvB"}

package/dist/lib/update-vessel.d.ts

@@ -0,0 +1,21 @@
+import { VesselDefinition } from '@maelstrom-co/protocol';
+import { MaelstromContextPair, MaelstromContextValue } from './context.js';
+import { AnyVesselEntry, UpdateVesselPayload, UpdateVesselResult, VesselIds } from './vessel-entry-types.js';
+/** Identifies which public API triggered a republish, for error messages. */
+type RepublishCaller = 'updateVessel' | 'handle.update';
+/**
+ * Runtime guards + republish shared by `m.updateVessel()` and
+ * `handle.update()` — the two call sites differ only in how `Id`/`V` gets
+ * checked at compile time before this ever runs, so the resolved-context
+ * caller passes in an already-`requireContext`'d `ctx`.
+ */
+export declare function republishVesselDefinition(ctx: MaelstromContextValue, vessel: VesselDefinition, caller: RepublishCaller): UpdateVesselResult;
+/**
+ * Factory that creates m.updateVessel() bound to a specific Maelstrom context.
+ *
+ * Component registries are deliberately untouched — that is what keeps
+ * stateful components alive across a republish.
+ */
+export declare function createUpdateVessel<T extends readonly AnyVesselEntry[]>(contextPair: MaelstromContextPair): <Id extends VesselIds<T>>(vessel: UpdateVesselPayload<T, Id>) => UpdateVesselResult;
+export {};
+//# sourceMappingURL=update-vessel.d.ts.map

package/dist/lib/update-vessel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-vessel.d.ts","sourceRoot":"","sources":["../../src/lib/update-vessel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAU,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAGvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEhF,OAAO,KAAK,EACV,cAAc,EAEd,mBAAmB,EACnB,kBAAkB,EAClB,SAAS,EACV,MAAM,yBAAyB,CAAC;AAEjC,6EAA6E;AAC7E,KAAK,eAAe,GAAG,cAAc,GAAG,eAAe,CAAC;AAExD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,qBAAqB,EAC1B,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,eAAe,GACtB,kBAAkB,CAkFpB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,SAAS,cAAc,EAAE,EACpE,WAAW,EAAE,oBAAoB,IAIJ,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EAClD,QAAQ,mBAAmB,CAAC,CAAC,EAAE,EAAE,CAAC,KACjC,kBAAkB,CAItB"}

package/dist/lib/use-actions.d.ts

@@ -0,0 +1,19 @@
+import { ActionRunner } from '@maelstrom-co/client';
+import { MaelstromContextPair } from './context.js';
+import { AnyVesselEntry, ExtractVesselByIdFromEntries, VesselIds } from './vessel-entry-types.js';
+/**
+ * Factory that creates the m.useActions() hook bound to a specific Maelstrom context.
+ *
+ * The returned hook registers typed side-effect handlers for actions dispatched to an instance
+ * (both engine-initiated and user-initiated via executeAction).
+ * Handlers are registered with the CommandProcessor on mount and unregistered on unmount.
+ *
+ * Pass a stable runner reference (defined outside the component or wrapped in useMemo)
+ * to prevent unnecessary re-registrations on each render.
+ *
+ * Limitation: only one useActions call per instanceId is supported. If two components
+ * register runners for the same instanceId, the second overwrites the first.
+ * Disposal is identity-checked, so unmounting the first will not affect the second's runner.
+ */
+export declare function createUseActions<const T extends readonly AnyVesselEntry[]>(contextPair: MaelstromContextPair): <Id extends VesselIds<T>>(vesselId: Id, instanceId: string, runner: ActionRunner<ExtractVesselByIdFromEntries<T, Id>>) => void;
+//# sourceMappingURL=use-actions.d.ts.map

package/dist/lib/use-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-actions.d.ts","sourceRoot":"","sources":["../../src/lib/use-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAKzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EACV,cAAc,EACd,4BAA4B,EAC5B,SAAS,EACV,MAAM,yBAAyB,CAAC;AAGjC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,cAAc,EAAE,EACxE,WAAW,EAAE,oBAAoB,IAIN,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EAChD,UAAU,EAAE,EACZ,YAAY,MAAM,EAClB,QAAQ,YAAY,CAAC,4BAA4B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KACxD,IAAI,CA8BR"}

package/dist/lib/use-instance.d.ts

@@ -0,0 +1,11 @@
+import { MaelstromContextPair } from './context.js';
+import { UntypedVesselProps } from './dynamic-vessel-types.js';
+/**
+ * Factory that creates the m.useInstance() hook — an untyped escape hatch.
+ *
+ * Unlike useVessel, this hook does not require a vesselId parameter and works
+ * for both statically and dynamically registered vessels. The trade-off is
+ * that variantProps is `Record<string, unknown>` and action names are `string`.
+ */
+export declare function createUseInstance(contextPair: MaelstromContextPair): (instanceId: string) => UntypedVesselProps | null;
+//# sourceMappingURL=use-instance.d.ts.map

package/dist/lib/use-instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-instance.d.ts","sourceRoot":"","sources":["../../src/lib/use-instance.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAIpE;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,oBAAoB,IAIrC,YAAY,MAAM,KAAG,kBAAkB,GAAG,IAAI,CAiC3E"}

package/dist/lib/use-intent-submission.d.ts

@@ -0,0 +1,8 @@
+import { IntentSnapshot, IntentSubmission } from '@maelstrom-co/client';
+/**
+ * Observe a client ticket through atomic application settlement, or null before
+ * submission. Subscription cleanup never cancels work. Operational failures are
+ * terminal snapshots, not thrown errors; unknown must not be retried automatically.
+ */
+export declare function useIntentSubmission(submission: IntentSubmission | null): IntentSnapshot | null;
+//# sourceMappingURL=use-intent-submission.d.ts.map

package/dist/lib/use-intent-submission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-intent-submission.d.ts","sourceRoot":"","sources":["../../src/lib/use-intent-submission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7E;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,gBAAgB,GAAG,IAAI,GAClC,cAAc,GAAG,IAAI,CAavB"}

package/dist/lib/use-latest-ref.d.ts

@@ -0,0 +1,4 @@
+import { RefObject } from 'react';
+/** Returns a ref that always holds the latest value, updated synchronously on each render. */
+export declare function useLatestRef<T>(value: T): RefObject<T>;
+//# sourceMappingURL=use-latest-ref.d.ts.map

package/dist/lib/use-latest-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-latest-ref.d.ts","sourceRoot":"","sources":["../../src/lib/use-latest-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,OAAO,CAAC;AAE/C,8FAA8F;AAC9F,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAItD"}

package/dist/lib/use-maelstrom.d.ts

@@ -0,0 +1,7 @@
+import { MaelstromContextPair } from './context.js';
+import { MaelstromState } from './maelstrom-state-types.js';
+export declare function createUseMaelstrom(contextPair: MaelstromContextPair): {
+    (): MaelstromState;
+    <T>(selector: (state: MaelstromState) => T): T;
+};
+//# sourceMappingURL=use-maelstrom.d.ts.map

package/dist/lib/use-maelstrom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-maelstrom.d.ts","sourceRoot":"","sources":["../../src/lib/use-maelstrom.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEjE,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,oBAAoB;QAGzC,cAAc;KACjB,CAAC,YAAY,CAAC,KAAK,EAAE,cAAc,KAAK,CAAC,GAAG,CAAC;EA0EpE"}

package/dist/lib/use-store-selector.d.ts

@@ -0,0 +1,17 @@
+/** Callback takes no args — getSnapshot reads .state directly, not the subscriber value. */
+interface Subscribable {
+    subscribe: (cb: () => void) => {
+        unsubscribe: () => void;
+    };
+}
+/**
+ * Subscribes to one or more TanStack stores via `useSyncExternalStore`.
+ * On each store notification, `buildSnapshot` composes a fresh value.
+ * If `selector` is provided, it narrows the snapshot before returning.
+ * Shallow equality prevents re-renders when the derived value hasn't changed.
+ */
+export declare function useStoreSelector<T>(stores: Subscribable[], buildSnapshot: () => T): T;
+export declare function useStoreSelector<T, S>(stores: Subscribable[], buildSnapshot: () => T, selector: (snapshot: T) => S): S;
+export declare function useStoreSelector<T, S>(stores: Subscribable[], buildSnapshot: () => T, selector: ((snapshot: T) => S) | undefined): T | S;
+export {};
+//# sourceMappingURL=use-store-selector.d.ts.map

package/dist/lib/use-store-selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-store-selector.d.ts","sourceRoot":"","sources":["../../src/lib/use-store-selector.ts"],"names":[],"mappings":"AAIA,4FAA4F;AAC5F,UAAU,YAAY;IACpB,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,KAAK;QAAE,WAAW,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;CAC5D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,MAAM,EAAE,YAAY,EAAE,EACtB,aAAa,EAAE,MAAM,CAAC,GACrB,CAAC,CAAC;AACL,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,MAAM,EAAE,YAAY,EAAE,EACtB,aAAa,EAAE,MAAM,CAAC,EACtB,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAC3B,CAAC,CAAC;AACL,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,MAAM,EAAE,YAAY,EAAE,EACtB,aAAa,EAAE,MAAM,CAAC,EACtB,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,GACzC,CAAC,GAAG,CAAC,CAAC"}

package/dist/lib/use-vessel-core.d.ts

@@ -0,0 +1,18 @@
+import { InstanceId, VariantName, VesselId } from '@maelstrom-co/protocol';
+import { MaelstromContextPair } from './context.js';
+export interface VesselCoreResult {
+    instanceId: InstanceId;
+    vesselId: VesselId;
+    currentVariant: VariantName;
+    variantProps: Record<string, unknown>;
+    executeAction: (name: string, params?: Record<string, unknown>) => void;
+}
+/**
+ * Factory that creates a useVesselCore hook bound to a specific Maelstrom context.
+ *
+ * The returned hook subscribes to a vessel instance from the client store.
+ * Variant transitions are owned by the client (see `Orchestrator.invokeAction`),
+ * so this hook simply reflects the store's authoritative variant.
+ */
+export declare function createUseVesselCore(contextPair: MaelstromContextPair): (vesselId: string | undefined, instanceId: string) => VesselCoreResult | null;
+//# sourceMappingURL=use-vessel-core.d.ts.map

package/dist/lib/use-vessel-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-vessel-core.d.ts","sourceRoot":"","sources":["../../src/lib/use-vessel-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAKhF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAGzD,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,cAAc,EAAE,WAAW,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CACzE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,oBAAoB,IAIjE,UAAU,MAAM,GAAG,SAAS,EAC5B,YAAY,MAAM,KACjB,gBAAgB,GAAG,IAAI,CA0D3B"}

package/dist/lib/use-vessel.d.ts

@@ -0,0 +1,7 @@
+import { MaelstromContextPair } from './context.js';
+import { AnyVesselEntry, ExtractVesselByIdFromEntries, TypedVesselProps, VesselIds } from './vessel-entry-types.js';
+/**
+ * Factory that creates the m.useVessel() hook bound to a specific Maelstrom context.
+ */
+export declare function createUseVessel<const T extends readonly AnyVesselEntry[]>(contextPair: MaelstromContextPair): <Id extends VesselIds<T>>(vesselId: Id, instanceId: string) => TypedVesselProps<ExtractVesselByIdFromEntries<T, Id>> | null;
+//# sourceMappingURL=use-vessel.d.ts.map

package/dist/lib/use-vessel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-vessel.d.ts","sourceRoot":"","sources":["../../src/lib/use-vessel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EACV,cAAc,EACd,4BAA4B,EAC5B,gBAAgB,EAChB,SAAS,EACV,MAAM,yBAAyB,CAAC;AAGjC;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,cAAc,EAAE,EACvE,WAAW,EAAE,oBAAoB,IAKP,EAAE,SAAS,SAAS,CAAC,CAAC,CAAC,EAC/C,UAAU,EAAE,EACZ,YAAY,MAAM,KACjB,gBAAgB,CAAC,4BAA4B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,IAAI,CA0BhE"}