js-bao-wss-client 2.2.0-alpha.6 → 2.2.0-alpha.7

package/dist/JsBaoClient.d.ts

@@ -93,7 +93,7 @@ export type { DocumentDebugSnapshot, DocumentPermission, LocalDocumentEntry, Loc
 export type { LogLevel } from "./internal/logger";
 export type { RequestOptions } from "./internal/httpClient";
 export type { LocksAPI } from "./api/locksApi";
-export type { FunctionsAPI, FunctionInvokeOptions, FunctionInvokeResult, FunctionInvokeStatus, FunctionInvokeLimits, FunctionStartOptions, FunctionStartResult, FunctionRunRef, } from "./api/functionsApi";
+export type { FunctionsAPI, FunctionInvokeOptions, FunctionInvokeResult, FunctionInvokeStatus, FunctionInvokeLimits, FunctionStartOptions, FunctionStartResult, FunctionRunRef, FunctionWaitForResult, } from "./api/functionsApi";
 export type { LockHandle, LockContention, AcquireResponse, AcquireOptions, BlockingAcquireOptions, ReleaseResult, RenewResult, LockStatus, LockListEntry, LockListResult, } from "./api/locksApi";
 export type { ResourceMetadataAPI } from "./api/resourceMetadataApi";
 export type { ResourceMetadataReadResult, ResourceMetadataWriteResult, ResourceMetadataBatchRequestItem, ResourceMetadataBatchParams, ResourceMetadataBatchCategoryResult, ResourceMetadataBatchResourceResult, ResourceMetadataBatchResult, ResourceMetadataListEntry, ResourceMetadataListResult, ResourceMetadataDeleteResult, ResourceMetadataResolveParams, ResourceMetadataResolveResult, } from "./api/resourceMetadataApi";

package/dist/api/functionsApi.d.ts

@@ -1,12 +1,12 @@
-import type { JsBaoClient, ClaimApplyResult, ConfirmApplyResult, ReleaseApplyResult, WaitForWorkflowOptions, WaitForWorkflowResult, WorkflowStatusResult } from "../JsBaoClient";
+import type { JsBaoClient, WaitForWorkflowOptions, WaitForWorkflowResult, WorkflowStatusResult } from "../JsBaoClient";
 /**
  * Server functions — client surface.
  *
  * A function is TypeScript an app's team authored, pushed with `primitive
  * config push`, and invokes over HTTP. This is the whole client contract for
- * the synchronous path; durable functions add to it without changing it.
+ * the request path; task functions add to it without changing it.
  */
-/** How a synchronous invocation settled. */
+/** How a request invocation settled. */
 export type FunctionInvokeStatus = "completed" | "failed" | "timeout";
 /**
  * The resolved platform ceilings an invocation ran under.
@@ -24,7 +24,7 @@ export interface FunctionInvokeLimits {
 /**
  * The invoke envelope.
  *
- * Deliberately without a `runId`: the synchronous path writes no run row, so
+ * Deliberately without a `runId`: the request path writes no run row, so
  * there is nothing to look up afterwards. A function that throws or times out
  * is a settled invocation with a terminal `status`, NOT a transport error —
  * only the platform refusing the call before the code ran (access, disabled,
@@ -64,7 +64,7 @@ export interface FunctionInvokeOptions<TInput = unknown> {
     timeoutMs?: number;
 }
 /**
- * The workflow START envelope, which a durable function answers with.
+ * The workflow START envelope, which a task function answers with.
  *
  * Identical to what `workflows.start` returns, deliberately: intent criterion 2
  * is that a caller "polls its run id exactly as for a DSL workflow today", and
@@ -80,7 +80,7 @@ export interface FunctionStartResult {
     output?: unknown;
     error?: string;
 }
-/** What to send with a durable start. */
+/** What to send with a task start. */
 export interface FunctionStartOptions<TInput = unknown> {
     /** The value the handler receives as its `input` (travels as `rootInput`). */
     input?: TInput;
@@ -94,6 +94,14 @@ export interface FunctionStartOptions<TInput = unknown> {
     /** Caller metadata, at most 1 KB encoded. */
     meta?: Record<string, unknown>;
 }
+/**
+ * What `functions.waitFor` resolves with: the terminal workflow-wait envelope
+ * with `output` typed by the caller's generic rather than inherited as `any`.
+ * `TOutput` defaults to `any`, so a bare caller is unchanged.
+ */
+export type FunctionWaitForResult<TOutput = any> = Omit<WaitForWorkflowResult, "output"> & {
+    output?: TOutput;
+};
 /**
  * Addressing one function run for the control routes.
  *
@@ -125,7 +133,7 @@ export declare class FunctionsAPI {
      */
     invoke<TOutput = unknown, TInput = unknown>(functionKey: string, options?: FunctionInvokeOptions<TInput>): Promise<FunctionInvokeResult<TOutput>>;
     /**
-     * Start a DURABLE server function and get its run id back.
+     * Start a TASK server function and get its run id back.
      *
      * The run is polled on exactly the routes a DSL workflow run is, which is
      * why the methods below are aliases rather than a parallel protocol.
@@ -155,33 +163,13 @@ export declare class FunctionsAPI {
      * The interval starts short and backs off, so a function that finishes in a
      * second is not waited out and one that sleeps for an hour is not polled
      * thousands of times.
+     *
+     * `output` is typed by `TOutput`: the inherited `WaitForWorkflowResult.output`
+     * is `any`, and an intersection with `any` is `any`, so the inherited member
+     * is replaced rather than intersected. With the default `any` a caller that
+     * never named `TOutput` reads exactly what it did.
      */
-    waitFor<TOutput = unknown>(runId: string, options?: WaitForWorkflowOptions): Promise<WaitForWorkflowResult & {
-        output?: TOutput;
-    }>;
+    waitFor<TOutput = any>(runId: string, options?: WaitForWorkflowOptions): Promise<FunctionWaitForResult<TOutput>>;
     /** Terminate a running function run. */
     terminate<TOutput = unknown>(ref: FunctionRunRef): Promise<WorkflowStatusResult<TOutput>>;
-    /**
-     * Claim a function run's result for a client-side apply.
-     *
-     * Kept for shape parity with workflow runs: a function run never enters the
-     * apply flow (nothing on this path produces a client-apply payload), so this
-     * answers the existing refusal rather than being absent. A caller writing one
-     * code path over both kinds of run gets the same envelope either way.
-     */
-    claimApply(ref: FunctionRunRef): Promise<ClaimApplyResult>;
-    /**
-     * Release a claimed apply so another client can retry it.
-     *
-     * Kept for shape parity with workflow runs; a function run has no
-     * client-apply step to release, so this answers the existing refusal.
-     */
-    releaseApply(ref: FunctionRunRef): Promise<ReleaseApplyResult>;
-    /**
-     * Confirm that a claimed apply has been written to the document.
-     *
-     * Kept for shape parity with workflow runs; a function run has no
-     * client-apply step to confirm, so this answers the existing refusal.
-     */
-    confirmApply(ref: FunctionRunRef): Promise<ConfirmApplyResult>;
 }

package/dist/api/functionsApi.js

@@ -26,19 +26,20 @@ export class FunctionsAPI {
                 ? {}
                 : { timeoutMs: options.timeoutMs }),
         });
-        // The route is one route and the MODE decides what it answers. A durable
+        // The route is one route and the MODE decides what it answers. A task
         // function answers the start envelope, which has no `output` and no
         // terminal `status` — everything this method's return type promises. Say
         // so, rather than handing back an object whose `output` is undefined for a
-        // run that has not finished (#3186).
+        // run that has not finished (#3186). In the mode words (#3281): the config
+        // key is `mode = "request" | "task"`, and the message speaks it.
         if (isStartEnvelope(response)) {
-            throw new JsBaoError("FUNCTION_MODE_MISMATCH", `Function '${functionKey}' is durable: it starts a RUN rather than returning a result. ` +
+            throw new JsBaoError("FUNCTION_MODE_MISMATCH", `Function '${functionKey}' is a task function: it starts a RUN rather than returning a result. ` +
                 `Call functions.start(key, options) and poll with functions.getStatus / functions.waitFor.`, { functionKey, runId: response.runId });
         }
         return response;
     }
     /**
-     * Start a DURABLE server function and get its run id back.
+     * Start a TASK server function and get its run id back.
      *
      * The run is polled on exactly the routes a DSL workflow run is, which is
      * why the methods below are aliases rather than a parallel protocol.
@@ -54,11 +55,11 @@ export class FunctionsAPI {
             ...(options.contextDocId ? { contextDocId: options.contextDocId } : {}),
             ...(options.meta ? { meta: options.meta } : {}),
         });
-        // The mirror of the check in `invoke`: a synchronous function ran and
+        // The mirror of the check in `invoke`: a request function ran and
         // answered with its RESULT, so there is no run id to poll and every method
         // below would have nothing to address.
         if (!isStartEnvelope(response)) {
-            throw new JsBaoError("FUNCTION_MODE_MISMATCH", `Function '${functionKey}' is synchronous: it returns a result rather than starting a run. ` +
+            throw new JsBaoError("FUNCTION_MODE_MISMATCH", `Function '${functionKey}' is a request function: it returns a result rather than starting a run. ` +
                 `Call functions.invoke(key, options) instead.`, { functionKey, status: response?.status });
         }
         return response;
@@ -95,6 +96,11 @@ export class FunctionsAPI {
      * The interval starts short and backs off, so a function that finishes in a
      * second is not waited out and one that sleeps for an hour is not polled
      * thousands of times.
+     *
+     * `output` is typed by `TOutput`: the inherited `WaitForWorkflowResult.output`
+     * is `any`, and an intersection with `any` is `any`, so the inherited member
+     * is replaced rather than intersected. With the default `any` a caller that
+     * never named `TOutput` reads exactly what it did.
      */
     async waitFor(runId, options) {
         if (!runId || typeof runId !== "string") {
@@ -134,35 +140,6 @@ export class FunctionsAPI {
     async terminate(ref) {
         return this.client.workflows.terminate(asWorkflowRef(ref));
     }
-    /**
-     * Claim a function run's result for a client-side apply.
-     *
-     * Kept for shape parity with workflow runs: a function run never enters the
-     * apply flow (nothing on this path produces a client-apply payload), so this
-     * answers the existing refusal rather than being absent. A caller writing one
-     * code path over both kinds of run gets the same envelope either way.
-     */
-    async claimApply(ref) {
-        return this.client.workflows.claimApply(asWorkflowRef(ref));
-    }
-    /**
-     * Release a claimed apply so another client can retry it.
-     *
-     * Kept for shape parity with workflow runs; a function run has no
-     * client-apply step to release, so this answers the existing refusal.
-     */
-    async releaseApply(ref) {
-        return this.client.workflows.releaseApply(asWorkflowRef(ref));
-    }
-    /**
-     * Confirm that a claimed apply has been written to the document.
-     *
-     * Kept for shape parity with workflow runs; a function run has no
-     * client-apply step to confirm, so this answers the existing refusal.
-     */
-    async confirmApply(ref) {
-        return this.client.workflows.confirmApply(asWorkflowRef(ref));
-    }
 }
 /** 15 minutes, matching `workflows.waitFor`'s default. */
 const FUNCTION_WAIT_DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
@@ -197,9 +174,9 @@ function asWorkflowRef(ref) {
 /**
  * Is this the workflow START envelope rather than a settled invocation?
  *
- * `runId` is the discriminator, and it is a good one: the synchronous path
+ * `runId` is the discriminator, and it is a good one: the request path
  * writes no run row precisely so that there is nothing to poll, so a `runId` on
- * this route means a durable start and nothing else.
+ * this route means a task start and nothing else.
  */
 function isStartEnvelope(value) {
     return (value !== null &&

package/dist/browser.umd.js

@@ -4407,7 +4407,6 @@
                 browser_version: event.browser_version ?? device.browserVersion,
                 app_version: event.app_version,
                 context_json: truncatedContext,
-                user_created_at_epoch_s: event.user_created_at_epoch_s,
             };
         }
         function chunkBySize(events, connectionId) {
@@ -14981,19 +14980,20 @@
                     ? {}
                     : { timeoutMs: options.timeoutMs }),
             });
-            // The route is one route and the MODE decides what it answers. A durable
+            // The route is one route and the MODE decides what it answers. A task
             // function answers the start envelope, which has no `output` and no
             // terminal `status` — everything this method's return type promises. Say
             // so, rather than handing back an object whose `output` is undefined for a
-            // run that has not finished (#3186).
+            // run that has not finished (#3186). In the mode words (#3281): the config
+            // key is `mode = "request" | "task"`, and the message speaks it.
             if (isStartEnvelope(response)) {
-                throw new JsBaoError("FUNCTION_MODE_MISMATCH", `Function '${functionKey}' is durable: it starts a RUN rather than returning a result. ` +
+                throw new JsBaoError("FUNCTION_MODE_MISMATCH", `Function '${functionKey}' is a task function: it starts a RUN rather than returning a result. ` +
                     `Call functions.start(key, options) and poll with functions.getStatus / functions.waitFor.`, { functionKey, runId: response.runId });
             }
             return response;
         }
         /**
-         * Start a DURABLE server function and get its run id back.
+         * Start a TASK server function and get its run id back.
          *
          * The run is polled on exactly the routes a DSL workflow run is, which is
          * why the methods below are aliases rather than a parallel protocol.
@@ -15009,11 +15009,11 @@
                 ...(options.contextDocId ? { contextDocId: options.contextDocId } : {}),
                 ...(options.meta ? { meta: options.meta } : {}),
             });
-            // The mirror of the check in `invoke`: a synchronous function ran and
+            // The mirror of the check in `invoke`: a request function ran and
             // answered with its RESULT, so there is no run id to poll and every method
             // below would have nothing to address.
             if (!isStartEnvelope(response)) {
-                throw new JsBaoError("FUNCTION_MODE_MISMATCH", `Function '${functionKey}' is synchronous: it returns a result rather than starting a run. ` +
+                throw new JsBaoError("FUNCTION_MODE_MISMATCH", `Function '${functionKey}' is a request function: it returns a result rather than starting a run. ` +
                     `Call functions.invoke(key, options) instead.`, { functionKey, status: response?.status });
             }
             return response;
@@ -15050,6 +15050,11 @@
          * The interval starts short and backs off, so a function that finishes in a
          * second is not waited out and one that sleeps for an hour is not polled
          * thousands of times.
+         *
+         * `output` is typed by `TOutput`: the inherited `WaitForWorkflowResult.output`
+         * is `any`, and an intersection with `any` is `any`, so the inherited member
+         * is replaced rather than intersected. With the default `any` a caller that
+         * never named `TOutput` reads exactly what it did.
          */
         async waitFor(runId, options) {
             if (!runId || typeof runId !== "string") {
@@ -15089,35 +15094,6 @@
         async terminate(ref) {
             return this.client.workflows.terminate(asWorkflowRef(ref));
         }
-        /**
-         * Claim a function run's result for a client-side apply.
-         *
-         * Kept for shape parity with workflow runs: a function run never enters the
-         * apply flow (nothing on this path produces a client-apply payload), so this
-         * answers the existing refusal rather than being absent. A caller writing one
-         * code path over both kinds of run gets the same envelope either way.
-         */
-        async claimApply(ref) {
-            return this.client.workflows.claimApply(asWorkflowRef(ref));
-        }
-        /**
-         * Release a claimed apply so another client can retry it.
-         *
-         * Kept for shape parity with workflow runs; a function run has no
-         * client-apply step to release, so this answers the existing refusal.
-         */
-        async releaseApply(ref) {
-            return this.client.workflows.releaseApply(asWorkflowRef(ref));
-        }
-        /**
-         * Confirm that a claimed apply has been written to the document.
-         *
-         * Kept for shape parity with workflow runs; a function run has no
-         * client-apply step to confirm, so this answers the existing refusal.
-         */
-        async confirmApply(ref) {
-            return this.client.workflows.confirmApply(asWorkflowRef(ref));
-        }
     }
     /** 15 minutes, matching `workflows.waitFor`'s default. */
     const FUNCTION_WAIT_DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
@@ -15152,9 +15128,9 @@
     /**
      * Is this the workflow START envelope rather than a settled invocation?
      *
-     * `runId` is the discriminator, and it is a good one: the synchronous path
+     * `runId` is the discriminator, and it is a good one: the request path
      * writes no run row precisely so that there is nothing to poll, so a `runId` on
-     * this route means a durable start and nothing else.
+     * this route means a task start and nothing else.
      */
     function isStartEnvelope(value) {
         return (value !== null &&

package/dist/internal/analyticsQueue.d.ts

@@ -27,6 +27,10 @@ export interface AnalyticsEventInput {
     browser_version?: string;
     app_version?: string;
     context_json?: Record<string, unknown> | string | null;
+    /**
+     * @deprecated Ignored. The server records when the user joined the app; any
+     * value passed here is dropped before the event is sent.
+     */
     user_created_at_epoch_s?: number;
 }
 export interface AnalyticsPreparedEvent {
@@ -44,7 +48,6 @@ export interface AnalyticsPreparedEvent {
     browser_version?: string;
     app_version?: string;
     context_json?: string;
-    user_created_at_epoch_s?: number;
 }
 export interface AnalyticsBatchMessage {
     type: typeof ANALYTICS_MESSAGE_TYPE;

package/dist/internal/analyticsQueue.js

@@ -206,7 +206,6 @@ export function createAnalyticsQueue(options) {
             browser_version: event.browser_version ?? device.browserVersion,
             app_version: event.app_version,
             context_json: truncatedContext,
-            user_created_at_epoch_s: event.user_created_at_epoch_s,
         };
     }
     function chunkBySize(events, connectionId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-bao-wss-client",
-  "version": "2.2.0-alpha.6",
+  "version": "2.2.0-alpha.7",
   "description": "Client library for js-bao-wss Yjs WebSocket service",
   "author": "Primitive LLC",
   "license": "UNLICENSED",
@@ -36,7 +36,7 @@
   "peerDependencies": {
     "lib0": "^0.2.0",
     "yjs": "^13.6.0",
-    "js-bao": "0.7.0-alpha.1",
+    "js-bao": "0.7.0-alpha.2",
     "better-sqlite3": "^11.0.0",
     "y-sqlite3": "^0.1.0",
     "react": ">=17.0.0",