@zakstam/codex-local-component 0.6.0 → 0.7.0

package/LLMS.md

@@ -0,0 +1,103 @@
+# LLMS: Canonical Consumer Integration (Single Path)
+
+Canonical default: runtime-owned host integration (`dispatchManaged: false`).
+
+## Hard Rule
+
+- Follow this file as the only default implementation strategy.
+- Do not implement dispatch-managed orchestration unless explicitly requested.
+- Do not handwrite host wrapper surfaces; generate them.
+- Always use app-generated Convex types from `./_generated/api` and `./_generated/server`.
+
+## Required Implementation Steps
+
+1. Install package dependencies.
+
+```bash
+pnpm add @zakstam/codex-local-component convex
+```
+
+2. Mount the component in `convex/convex.config.ts`.
+
+```ts
+import { defineApp } from "convex/server";
+import codexLocal from "@zakstam/codex-local-component/convex.config";
+
+const app = defineApp();
+app.use(codexLocal);
+
+export default app;
+```
+
+3. Generate host surfaces from the canonical manifest.
+
+```bash
+pnpm run host:generate
+```
+
+4. Keep host files in this split:
+
+- `convex/chat.generated.ts`: generated preset wrappers (do not edit)
+- `convex/chat.extensions.ts`: app-owned custom endpoints
+- `convex/chat.ts`: stable entrypoint (`export *` from generated + extensions)
+
+5. Use runtime-owned host preset behavior only.
+
+- Generated wrappers are based on `defineRuntimeOwnedHostSlice(...)`.
+- Runtime startup must be explicit runtime-owned:
+
+```ts
+await runtime.start({
+  actor,
+  sessionId,
+  dispatchManaged: false,
+  threadStrategy: "start",
+});
+```
+
+6. Start turns through `runtime.sendTurn(text)`.
+
+- Do not call `startClaimedTurn` in the canonical path.
+
+7. Validate host wiring during startup.
+
+- Query `chat.validateHostWiring` once at process boot.
+- Fail fast if `ok` is `false`.
+
+8. Use canonical host query/mutation endpoints in React hooks.
+
+- `useCodexMessages` -> `chat.listThreadMessagesForHooks`
+- `useCodexTurn` -> `chat.listTurnMessagesForHooks`
+- `useCodexApprovals` -> `chat.listPendingApprovalsForHooks` + `chat.respondApprovalForHooks`
+- `useCodexComposer` -> `chat.enqueueTurnDispatch`
+
+## Required Consumer Commands
+
+From repo root (or equivalent monorepo command wrappers):
+
+```bash
+pnpm run host:generate
+pnpm run host:check
+```
+
+From each host app:
+
+```bash
+pnpm run dev:convex:once
+pnpm run wiring:smoke
+pnpm run typecheck
+```
+
+## Required Host Surface Ownership
+
+- Generated surface owns preset endpoint exports.
+- Extensions file owns only app-specific endpoints.
+- Entrypoint file owns only re-exports.
+
+If an endpoint belongs to preset behavior, add it in the package preset/manifest and regenerate. Do not manually patch generated host files.
+
+## Advanced Appendix (Non-Default)
+
+Dispatch-managed orchestration is advanced and non-default. Reference only when explicitly requested:
+
+- `docs/DISPATCH_MANAGED_REFERENCE_HOST.md`

package/README.md

@@ -2,7 +2,9 @@
 
 [![npm version](https://img.shields.io/npm/v/%40zakstam%2Fcodex-local-component)](https://www.npmjs.com/package/@zakstam/codex-local-component)
 
-Convex component for Codex integrations where Codex runs locally on the user's machine (desktop/CLI), while thread state, messages, approvals, and stream recovery live in Convex.
+Convex component for Codex integrations where Codex runs locally while thread state, messages, approvals, and replay are persisted in Convex.
+
+Canonical default: runtime-owned host integration (`dispatchManaged: false`).
 
 ## Install
 
@@ -12,214 +14,25 @@ pnpm add @zakstam/codex-local-component convex
 
 React hooks require `react` peer dependency (`^18` or `^19`).
 
-## Integration Contract (Read First)
-
-1. Always use generated Convex types from your app:
-   - `./_generated/api`
-   - `./_generated/server`
-2. Mount the component once with `app.use(codexLocal)`.
-3. In Convex server files, use `@zakstam/codex-local-component/host/convex` helper exports.
-4. Treat `actor` (`tenantId`, `userId`, `deviceId`) as trusted server identity, not untrusted client input.
-5. Before ingesting events on startup/reconnect, call `sync.ensureSession`.
-6. For runtime ingest, prefer `sync.ingestSafe` (`ingestBatchMixed` uses this).
-7. Runtime dispatch ownership must be explicit:
-   - `dispatchManaged: false` -> runtime orchestrates via `sendTurn`
-   - `dispatchManaged: true` -> external worker orchestrates and runtime executes via `startClaimedTurn`
-8. Convex-deployed code should not import `@zakstam/codex-local-component/protocol/parser` (Ajv runtime validation). Use host wrappers and `protocol/events`-based helpers only.
-
-## Golden Path
-
-### 1) Mount the component
-
-```ts
-// convex/convex.config.ts
-import { defineApp } from "convex/server";
-import codexLocal from "@zakstam/codex-local-component/convex.config";
-
-const app = defineApp();
-app.use(codexLocal);
-
-export default app;
-```
-
-Run `npx convex dev` once so `components.codexLocal.*` is generated.
-
-### 2) Add host wrappers (`convex/chat.ts`)
-
-```ts
-import { paginationOptsValidator } from "convex/server";
-import { v } from "convex/values";
-import { mutation, query } from "./_generated/server";
-import { components } from "./_generated/api";
-import {
-  enqueueTurnDispatchForActor,
-  ensureSession as ensureSessionHandler,
-  ensureThreadByCreate,
-  ingestBatchMixed,
-  listThreadMessagesForHooksForActor,
-  vHostEnqueueTurnDispatchResult,
-  vHostActorContext,
-  vHostEnsureSessionResult,
-  vHostIngestSafeResult,
-  vHostLifecycleInboundEvent,
-  vHostStreamArgs,
-  vHostStreamInboundEvent,
-  vHostSyncRuntimeOptions,
-} from "@zakstam/codex-local-component/host/convex";
-
-const SERVER_ACTOR = {
-  tenantId: process.env.ACTOR_TENANT_ID ?? "demo-tenant",
-  userId: process.env.ACTOR_USER_ID ?? "demo-user",
-  deviceId: process.env.ACTOR_DEVICE_ID ?? "server-device",
-};
-
-export const ensureThread = mutation({
-  args: { actor: vHostActorContext, threadId: v.string() },
-  handler: async (ctx, args) => ensureThreadByCreate(ctx, components.codexLocal, args),
-});
-
-export const enqueueTurnDispatch = mutation({
-  args: {
-    actor: vHostActorContext,
-    threadId: v.string(),
-    turnId: v.string(),
-    idempotencyKey: v.string(),
-    input: v.array(
-      v.object({
-        type: v.string(),
-        text: v.optional(v.string()),
-        url: v.optional(v.string()),
-        path: v.optional(v.string()),
-      }),
-    ),
-  },
-  returns: vHostEnqueueTurnDispatchResult,
-  handler: async (ctx, args) =>
-    enqueueTurnDispatchForActor(ctx, components.codexLocal, args),
-});
-
-export const ensureSession = mutation({
-  args: { actor: vHostActorContext, sessionId: v.string(), threadId: v.string() },
-  returns: vHostEnsureSessionResult,
-  handler: async (ctx, args) => ensureSessionHandler(ctx, components.codexLocal, args),
-});
-
-export const ingestBatch = mutation({
-  args: {
-    actor: vHostActorContext,
-    sessionId: v.string(),
-    threadId: v.string(),
-    deltas: v.array(v.union(vHostStreamInboundEvent, vHostLifecycleInboundEvent)),
-    runtime: v.optional(vHostSyncRuntimeOptions),
-  },
-  returns: vHostIngestSafeResult,
-  handler: async (ctx, args) => ingestBatchMixed(ctx, components.codexLocal, args),
-});
-
-export const listThreadMessagesForHooks = query({
-  args: {
-    actor: vHostActorContext,
-    threadId: v.string(),
-    paginationOpts: paginationOptsValidator,
-    streamArgs: vHostStreamArgs,
-    runtime: v.optional(vHostSyncRuntimeOptions),
-  },
-  handler: async (ctx, args) =>
-    listThreadMessagesForHooksForActor(ctx, components.codexLocal, {
-      actor: SERVER_ACTOR,
-      threadId: args.threadId,
-      paginationOpts: args.paginationOpts,
-      streamArgs: args.streamArgs,
-      runtime: args.runtime,
-    }),
-});
-```
-
-### 3) Run bridge loop (desktop/CLI process)
-
-```ts
-import { randomUUID } from "node:crypto";
-import { ConvexHttpClient } from "convex/browser";
-import { CodexLocalBridge } from "@zakstam/codex-local-component/bridge";
-import { api } from "../convex/_generated/api.js";
-
-const convex = new ConvexHttpClient(process.env.CONVEX_URL!);
-const actor = { tenantId: "demo", userId: "demo", deviceId: "local-1" };
-const sessionId = randomUUID();
-let threadId: string | null = null;
-
-const bridge = new CodexLocalBridge(
-  { cwd: process.cwd() },
-  {
-    onEvent: async (event) => {
-      if (!threadId) {
-        threadId = event.threadId;
-        await convex.mutation(api.chat.ensureThread, { actor, threadId });
-        await convex.mutation(api.chat.ensureSession, { actor, sessionId, threadId });
-      }
+## Canonical Implementation
 
-      await convex.mutation(api.chat.ingestBatch, {
-        actor,
-        sessionId,
-        threadId: event.threadId,
-        deltas: [event],
-      });
-    },
-    onGlobalMessage: async () => {
-      // handle non-thread protocol messages (auth/config/etc)
-    },
-    onProtocolError: async ({ error, line }) => {
-      console.error("protocol error", error.message, line);
-    },
-  },
-);
+Use one source of truth for implementation steps:
 
-bridge.start();
-```
-
-### 4) Wire React hooks
-
-```tsx
-import { useCodexMessages } from "@zakstam/codex-local-component/react";
-import { api } from "../convex/_generated/api";
-
-const actor = { tenantId: "demo", userId: "demo", deviceId: "web-1" };
-
-export function Chat({ threadId }: { threadId: string }) {
-  const messages = useCodexMessages(
-    api.chat.listThreadMessagesForHooks,
-    { actor, threadId },
-    { initialNumItems: 30, stream: true },
-  );
-
-  return (
-    <div>
-      {messages.results.map((msg) => (
-        <div key={msg._id}>{msg.text}</div>
-      ))}
-    </div>
-  );
-}
-```
-
-## Required Query Contract for `useCodexMessages`
-
-Your host query must:
-
-- accept `threadId`, `paginationOpts`, optional `streamArgs`
-- return durable paginated messages plus optional `streams`
-
-`streamArgs`:
+- `./LLMS.md`
 
-- `{ kind: "list", startOrder?: number }`
-- `{ kind: "deltas", cursors: Array<{ streamId: string; cursor: number }> }`
+That file is the normative, single-path consumer strategy.
 
-Delta stream response shape includes:
+## Quickstart Summary
 
-- `streams`
-- `deltas`
-- `streamWindows` (`ok | rebased | stale`)
-- `nextCheckpoints`
+1. Mount component in `convex/convex.config.ts` with `app.use(codexLocal)`.
+2. Generate host surfaces with `pnpm run host:generate`.
+3. Keep host split:
+- `convex/chat.generated.ts` (generated)
+- `convex/chat.extensions.ts` (app-owned)
+- `convex/chat.ts` (re-exports)
+4. Start runtime in runtime-owned mode (`dispatchManaged: false`).
+5. Call `chat.validateHostWiring` at startup.
+6. Use `@zakstam/codex-local-component/react` hooks against canonical host endpoints.
 
 ## Package Import Paths
 
@@ -231,54 +44,17 @@ Delta stream response shape includes:
 - `@zakstam/codex-local-component/app-server`
 - `@zakstam/codex-local-component/protocol`
 
-## Dispatch v0.5 Canonical Mode
+## Docs Map
 
-Use one orchestration owner per runtime instance:
-
-- Runtime-owned mode: `createCodexHostRuntime(...).start({ dispatchManaged: false, ... })` and call `sendTurn(text)`.
-- External dispatch mode: `start({ dispatchManaged: true, ... })`, enqueue/claim via dispatch wrappers, then call `startClaimedTurn({ dispatchId, claimToken, turnId, inputText })`.
-
-Guardrail: mixing both APIs in one mode throws explicit runtime error codes (`E_RUNTIME_DISPATCH_*`).
-
-Reference guides:
-
-- `docs/RUNTIME_OWNED_REFERENCE_HOST.md` for `dispatchManaged: false`.
-- `docs/DISPATCH_MANAGED_REFERENCE_HOST.md` for `dispatchManaged: true`.
-
-## Implemented
-
-- Initialization handshake
-- Thread lifecycle (create, resolve, resume, fork, archive, rollback)
-- Turn lifecycle (start, interrupt, idempotency)
-- Streamed event ingest and replay with cursor-based sync
-- Session lifecycle (`ensureSession`, heartbeat, recovery)
-- Account/Auth API surface (`account/read`, `account/login/start`, `account/login/cancel`, `account/logout`, `account/rateLimits/read`)
-- Command execution and file change approval flows
-- Tool user input flow
-- Dynamic tool call response flow
-- ChatGPT auth-token refresh response flow (`account/chatgptAuthTokens/refresh`)
-- Multi-device stream checkpoints with TTL cleanup
-
-## Not Implemented Yet
-
-- Config management API surface
-- MCP management API surface
-- Core runtime utility APIs (`command/exec`, `model/list`, `review/start`)
-- Skill/App discovery and configuration APIs
-- Feedback API
-- Collaboration mode listing
-
-## Docs
-
-- `docs/HOST_INTEGRATION.md`
-- `docs/RUNTIME_OWNED_REFERENCE_HOST.md`
-- `docs/DISPATCH_MANAGED_REFERENCE_HOST.md`
-- `docs/CLIENT_AND_REACT_HOOKS.md`
-- `docs/OPERATIONS_AND_ERRORS.md`
+- Canonical implementation: `./LLMS.md`
+- Host details (aligned to canonical path): `docs/HOST_INTEGRATION.md`
+- Client and hooks contracts: `docs/CLIENT_AND_REACT_HOOKS.md`
+- Operations and errors: `docs/OPERATIONS_AND_ERRORS.md`
+- Reference matrix: `docs/HOST_PRESET_MATRIX.md`
+- Advanced appendix (non-default): `docs/DISPATCH_MANAGED_REFERENCE_HOST.md`
+- Runtime-owned reference details: `docs/RUNTIME_OWNED_REFERENCE_HOST.md`
 
 ## Type Safety Checks
 
 - `pnpm --filter @zakstam/codex-local-component run typecheck`
 - `pnpm --filter @zakstam/codex-local-component run check:unsafe-types`
-
-`check:unsafe-types` fails on handwritten-source `any` usage and on new casts outside `scripts/unsafe-cast-allowlist.txt` (generated files excluded).

package/dist/host/convex-entry.d.ts

@@ -1,4 +1,7 @@
+export { defineDispatchManagedHostSlice, defineRuntimeOwnedHostSlice, type CodexHostSliceFeatures, type CodexHostSliceIngestMode, type CodexHostSliceProfile, type CodexHostSliceThreadMode, type DefineDispatchManagedHostSliceOptions, type DefineRuntimeOwnedHostSliceOptions, type DispatchManagedHostDefinitions, type RuntimeOwnedHostDefinitions, } from "./convexPreset.js";
+export { wrapHostDefinitions } from "./wrapDefinitions.js";
+export { HOST_PRESET_DEFINITIONS, HOST_SURFACE_MANIFEST, type HostSurfaceProfile, type HostSurfaceMutationKey, type HostSurfaceQueryKey, } from "./surfaceManifest.js";
 export { ingestBatchSafe, listThreadMessagesForHooks, listThreadReasoningForHooks, type HostInboundLifecycleEvent, type HostInboundStreamDelta, type HostMessagesForHooksArgs, type HostReasoningForHooksArgs, type HostStreamArgs, type HostSyncRuntimeOptions, } from "./convex.js";
 export { normalizeInboundDeltas, type NormalizedInboundDelta, type NormalizedInboundLifecycleEvent, type NormalizedInboundStreamDelta, } from "./normalizeInboundDeltas.js";
-export { computeDataHygiene, computeDurableHistoryStats, computePersistenceStats, enqueueTurnDispatchForActor, claimNextTurnDispatchForActor, markTurnDispatchStartedForActor, markTurnDispatchCompletedForActor, markTurnDispatchFailedForActor, cancelTurnDispatchForActor, getTurnDispatchStateForActor, dispatchObservabilityForActor, dataHygiene, durableHistoryStats, ensureSession, ensureThreadByCreate, ensureThreadByResolve, ingestBatchMixed, ingestBatchStreamOnly, ingestEventMixed, ingestEventStreamOnly, interruptTurnForHooksForActor, isStreamStatSummary, listPendingApprovalsForHooksForActor, listPendingServerRequestsForHooksForActor, listThreadMessagesForHooksForActor, listThreadReasoningForHooksForActor, listTurnMessagesForHooksForActor, persistenceStats, respondApprovalForHooksForActor, resolvePendingServerRequestForHooksForActor, threadSnapshot, upsertPendingServerRequestForHooksForActor, vHostActorContext, vHostDataHygiene, vHostDurableHistoryStats, vHostDispatchStatus, vHostDispatchObservability, vHostEnqueueTurnDispatchResult, vHostClaimedTurnDispatch, vHostTurnDispatchState, vHostTurnInput, vHostEnsureSessionResult, vHostInboundEvent, vHostIngestSafeResult, vHostLifecycleInboundEvent, vHostPersistenceStats, vHostStreamArgs, vHostStreamInboundEvent, vHostSyncRuntimeOptions, type HostActorContext, } from "./convexSlice.js";
+export { computeDataHygiene, computeDurableHistoryStats, computePersistenceStats, enqueueTurnDispatchForActor, claimNextTurnDispatchForActor, markTurnDispatchStartedForActor, markTurnDispatchCompletedForActor, markTurnDispatchFailedForActor, cancelTurnDispatchForActor, getTurnDispatchStateForActor, dispatchObservabilityForActor, dataHygiene, durableHistoryStats, ensureSession, ensureThreadByCreate, ensureThreadByResolve, ingestBatchMixed, ingestBatchStreamOnly, ingestEventMixed, ingestEventStreamOnly, interruptTurnForHooksForActor, isStreamStatSummary, listPendingApprovalsForHooksForActor, listPendingServerRequestsForHooksForActor, listThreadMessagesForHooksForActor, listThreadReasoningForHooksForActor, listTurnMessagesForHooksForActor, persistenceStats, respondApprovalForHooksForActor, resolvePendingServerRequestForHooksForActor, threadSnapshot, upsertPendingServerRequestForHooksForActor, vHostActorContext, vHostDataHygiene, vHostDurableHistoryStats, vHostDispatchStatus, vHostDispatchObservability, vHostEnqueueTurnDispatchResult, vHostClaimedTurnDispatch, vHostTurnDispatchState, vHostTurnInput, vHostEnsureSessionResult, vHostInboundEvent, vHostIngestSafeResult, vHostLifecycleInboundEvent, vHostPersistenceStats, vHostStreamArgs, vHostStreamInboundEvent, vHostSyncRuntimeOptions, type CodexHostComponentRefs, type CodexHostComponentsInput, type HostActorContext, } from "./convexSlice.js";
 //# sourceMappingURL=convex-entry.d.ts.map

package/dist/host/convex-entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex-entry.d.ts","sourceRoot":"","sources":["../../src/host/convex-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,2BAA2B,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,sBAAsB,GAC5B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,kBAAkB,EAClB,0BAA0B,EAC1B,uBAAuB,EACvB,2BAA2B,EAC3B,6BAA6B,EAC7B,+BAA+B,EAC/B,iCAAiC,EACjC,8BAA8B,EAC9B,0BAA0B,EAC1B,4BAA4B,EAC5B,6BAA6B,EAC7B,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,6BAA6B,EAC7B,mBAAmB,EACnB,oCAAoC,EACpC,yCAAyC,EACzC,kCAAkC,EAClC,mCAAmC,EACnC,gCAAgC,EAChC,gBAAgB,EAChB,+BAA+B,EAC/B,2CAA2C,EAC3C,cAAc,EACd,0CAA0C,EAC1C,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,mBAAmB,EACnB,0BAA0B,EAC1B,8BAA8B,EAC9B,wBAAwB,EACxB,sBAAsB,EACtB,cAAc,EACd,wBAAwB,EACxB,iBAAiB,EACjB,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"convex-entry.d.ts","sourceRoot":"","sources":["../../src/host/convex-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC7B,KAAK,qCAAqC,EAC1C,KAAK,kCAAkC,EACvC,KAAK,8BAA8B,EACnC,KAAK,2BAA2B,GACjC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,GACzB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,2BAA2B,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,sBAAsB,GAC5B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,sBAAsB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACpC,KAAK,4BAA4B,GAClC,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,kBAAkB,EAClB,0BAA0B,EAC1B,uBAAuB,EACvB,2BAA2B,EAC3B,6BAA6B,EAC7B,+BAA+B,EAC/B,iCAAiC,EACjC,8BAA8B,EAC9B,0BAA0B,EAC1B,4BAA4B,EAC5B,6BAA6B,EAC7B,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,6BAA6B,EAC7B,mBAAmB,EACnB,oCAAoC,EACpC,yCAAyC,EACzC,kCAAkC,EAClC,mCAAmC,EACnC,gCAAgC,EAChC,gBAAgB,EAChB,+BAA+B,EAC/B,2CAA2C,EAC3C,cAAc,EACd,0CAA0C,EAC1C,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,mBAAmB,EACnB,0BAA0B,EAC1B,8BAA8B,EAC9B,wBAAwB,EACxB,sBAAsB,EACtB,cAAc,EACd,wBAAwB,EACxB,iBAAiB,EACjB,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC"}

package/dist/host/convex-entry.js

@@ -1,3 +1,6 @@
+export { defineDispatchManagedHostSlice, defineRuntimeOwnedHostSlice, } from "./convexPreset.js";
+export { wrapHostDefinitions } from "./wrapDefinitions.js";
+export { HOST_PRESET_DEFINITIONS, HOST_SURFACE_MANIFEST, } from "./surfaceManifest.js";
 export { ingestBatchSafe, listThreadMessagesForHooks, listThreadReasoningForHooks, } from "./convex.js";
 export { normalizeInboundDeltas, } from "./normalizeInboundDeltas.js";
 export { computeDataHygiene, computeDurableHistoryStats, computePersistenceStats, enqueueTurnDispatchForActor, claimNextTurnDispatchForActor, markTurnDispatchStartedForActor, markTurnDispatchCompletedForActor, markTurnDispatchFailedForActor, cancelTurnDispatchForActor, getTurnDispatchStateForActor, dispatchObservabilityForActor, dataHygiene, durableHistoryStats, ensureSession, ensureThreadByCreate, ensureThreadByResolve, ingestBatchMixed, ingestBatchStreamOnly, ingestEventMixed, ingestEventStreamOnly, interruptTurnForHooksForActor, isStreamStatSummary, listPendingApprovalsForHooksForActor, listPendingServerRequestsForHooksForActor, listThreadMessagesForHooksForActor, listThreadReasoningForHooksForActor, listTurnMessagesForHooksForActor, persistenceStats, respondApprovalForHooksForActor, resolvePendingServerRequestForHooksForActor, threadSnapshot, upsertPendingServerRequestForHooksForActor, vHostActorContext, vHostDataHygiene, vHostDurableHistoryStats, vHostDispatchStatus, vHostDispatchObservability, vHostEnqueueTurnDispatchResult, vHostClaimedTurnDispatch, vHostTurnDispatchState, vHostTurnInput, vHostEnsureSessionResult, vHostInboundEvent, vHostIngestSafeResult, vHostLifecycleInboundEvent, vHostPersistenceStats, vHostStreamArgs, vHostStreamInboundEvent, vHostSyncRuntimeOptions, } from "./convexSlice.js";

package/dist/host/convex-entry.js.map

@@ -1 +1 @@
-{"version":3,"file":"convex-entry.js","sourceRoot":"","sources":["../../src/host/convex-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,2BAA2B,GAO5B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,sBAAsB,GAIvB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,kBAAkB,EAClB,0BAA0B,EAC1B,uBAAuB,EACvB,2BAA2B,EAC3B,6BAA6B,EAC7B,+BAA+B,EAC/B,iCAAiC,EACjC,8BAA8B,EAC9B,0BAA0B,EAC1B,4BAA4B,EAC5B,6BAA6B,EAC7B,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,6BAA6B,EAC7B,mBAAmB,EACnB,oCAAoC,EACpC,yCAAyC,EACzC,kCAAkC,EAClC,mCAAmC,EACnC,gCAAgC,EAChC,gBAAgB,EAChB,+BAA+B,EAC/B,2CAA2C,EAC3C,cAAc,EACd,0CAA0C,EAC1C,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,mBAAmB,EACnB,0BAA0B,EAC1B,8BAA8B,EAC9B,wBAAwB,EACxB,sBAAsB,EACtB,cAAc,EACd,wBAAwB,EACxB,iBAAiB,EACjB,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACvB,uBAAuB,GAExB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"convex-entry.js","sourceRoot":"","sources":["../../src/host/convex-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,2BAA2B,GAS5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GAItB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,eAAe,EACf,0BAA0B,EAC1B,2BAA2B,GAO5B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,sBAAsB,GAIvB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,kBAAkB,EAClB,0BAA0B,EAC1B,uBAAuB,EACvB,2BAA2B,EAC3B,6BAA6B,EAC7B,+BAA+B,EAC/B,iCAAiC,EACjC,8BAA8B,EAC9B,0BAA0B,EAC1B,4BAA4B,EAC5B,6BAA6B,EAC7B,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,6BAA6B,EAC7B,mBAAmB,EACnB,oCAAoC,EACpC,yCAAyC,EACzC,kCAAkC,EAClC,mCAAmC,EACnC,gCAAgC,EAChC,gBAAgB,EAChB,+BAA+B,EAC/B,2CAA2C,EAC3C,cAAc,EACd,0CAA0C,EAC1C,iBAAiB,EACjB,gBAAgB,EAChB,wBAAwB,EACxB,mBAAmB,EACnB,0BAA0B,EAC1B,8BAA8B,EAC9B,wBAAwB,EACxB,sBAAsB,EACtB,cAAc,EACd,wBAAwB,EACxB,iBAAiB,EACjB,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACvB,uBAAuB,GAIxB,MAAM,kBAAkB,CAAC"}