@reboot-dev/reboot 0.33.1 → 0.35.0

package/index.d.ts

@@ -1,4 +1,5 @@
 import { errors_pb, IdempotencyOptions, protobuf_es, tasks_pb } from "@reboot-dev/reboot-api";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
 import { z } from "zod/v4";
 import * as reboot_native from "./reboot_native.cjs";
 import { Application as ExpressApplication, NextFunction as ExpressNextFunction, Request as ExpressRequest, Response as ExpressResponse } from "express";
@@ -52,30 +53,43 @@ export declare function runWithContext<T>(context: Context, callback: () => T):
 export declare class Context {
     #private;
     readonly cancelled: Promise<void>;
-    constructor(external: any, cancelled: Promise<void>);
-    static fromNativeExternal(external: any, kind: string, cancelled: Promise<void>): ReaderContext | WriterContext | TransactionContext | WorkflowContext;
+    readonly stateId: string;
+    readonly method: string;
+    readonly stateTypeName: string;
+    readonly callerBearerToken: string | null;
+    readonly cookie: string | null;
+    readonly appInternal: boolean;
+    readonly auth: Auth | null;
+    constructor({ external, stateId, method, stateTypeName, callerBearerToken, cookie, appInternal, auth, cancelled, }: {
+        external: any;
+        stateId: string;
+        method: string;
+        stateTypeName: string;
+        callerBearerToken: string | null;
+        cookie: string | null;
+        appInternal: boolean;
+        auth: Auth | null;
+        cancelled: Promise<void>;
+    });
+    static fromNativeExternal({ kind, ...options }: {
+        [x: string]: any;
+        kind: any;
+    }): ReaderContext | WriterContext | TransactionContext | WorkflowContext;
     get __external(): any;
-    get auth(): Auth | null;
-    get stateId(): string;
-    get stateTypeName(): string;
-    get method(): string;
-    get callerBearerToken(): string | null;
-    get cookie(): string;
-    get appInternal(): boolean;
     generateIdempotentStateId(stateType: string, serviceName: string, method: string, idempotency: IdempotencyOptions): Promise<any>;
 }
 export declare class ReaderContext extends Context {
     #private;
-    constructor(external: any, cancelled: any);
+    constructor(options: any);
 }
 export declare class WriterContext extends Context {
     #private;
-    constructor(external: any, cancelled: any);
+    constructor(options: any);
     set sync(sync: boolean);
 }
 export declare class TransactionContext extends Context {
     #private;
-    constructor(external: any, cancelled: any);
+    constructor(options: any);
 }
 export type Interval = {
     ms?: number;
@@ -86,7 +100,7 @@ export type Interval = {
 };
 export declare class WorkflowContext extends Context {
     #private;
-    constructor(external: any, cancelled: any);
+    constructor(options: any);
     loop(alias: string, { interval }?: {
         interval?: Interval;
     }): AsyncGenerator<number, void, unknown>;
@@ -140,7 +154,7 @@ export declare abstract class TokenVerifier {
      *   `Auth` information if the token is valid, null otherwise.
      */
     abstract verifyToken(context: ReaderContext, token?: string): Promise<Auth | null>;
-    _verifyToken(context: ReaderContext, token?: string): Promise<Uint8Array | null>;
+    _verifyToken(external: any, cancelled: Promise<void>, bytesCall: Uint8Array): Promise<Uint8Array | null>;
 }
 export type AuthorizerDecision = errors_pb.Unauthenticated | errors_pb.PermissionDenied | errors_pb.Ok;
 /**
@@ -164,7 +178,7 @@ export declare abstract class Authorizer<StateType, RequestTypes> {
      *         `errors_pb.PermissionDenied()` otherwise.
      */
     abstract authorize(methodName: string, context: ReaderContext, state?: StateType, request?: RequestTypes): Promise<AuthorizerDecision>;
-    _authorize?: (methodName: string, context: ReaderContext, bytesState?: Uint8Array, bytesRequest?: Uint8Array) => Promise<Uint8Array>;
+    _authorize?: (external: any, cancelled: Promise<void>, bytesCall: Uint8Array) => Promise<Uint8Array>;
 }
 export type AuthorizerCallable<StateType, RequestType> = (args: {
     context: ReaderContext;
@@ -232,7 +246,7 @@ export declare namespace Application {
     }
 }
 export declare function retryReactivelyUntil(context: WorkflowContext, condition: () => Promise<boolean>): Promise<void>;
-export declare function retryReactivelyUntil<T>(context: WorkflowContext, condition: () => Promise<false | Exclude<T, boolean>>): Promise<Exclude<T, boolean>>;
+export declare function retryReactivelyUntil<T>(context: WorkflowContext, condition: () => Promise<false | T>): Promise<T>;
 export declare const ALWAYS: "ALWAYS";
 export declare const PER_WORKFLOW: "PER_WORKFLOW";
 export declare const PER_ITERATION: "PER_ITERATION";
@@ -242,99 +256,49 @@ export type AtMostLeastOnceTupleType = [
     "PER_WORKFLOW" | "PER_ITERATION"
 ];
 export declare function atMostOnce(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<void>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function atMostOnce<T>(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<T>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<T>;
+export declare function atMostOnce<Schema extends StandardSchemaV1>(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare function atMostOncePerWorkflow(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<void>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function atMostOncePerWorkflow<T>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<T>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<T>;
+export declare function atMostOncePerWorkflow<Schema extends StandardSchemaV1>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare function atLeastOnce(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<void>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function atLeastOnce<T>(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<T>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<T>;
+export declare function atLeastOnce<Schema extends StandardSchemaV1>(idempotencyAliasOrTuple: string | AtMostLeastOnceTupleType, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare function atLeastOncePerWorkflow(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<void>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function atLeastOncePerWorkflow<T>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<T>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<T>;
+export declare function atLeastOncePerWorkflow<Schema extends StandardSchemaV1>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export type UntilTupleType = [
     string,
     "ALWAYS" | "PER_WORKFLOW" | "PER_ITERATION"
 ];
 export declare function until(idempotencyAliasOrTuple: string | UntilTupleType, context: WorkflowContext, callable: () => Promise<boolean>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function until<T>(idempotencyAliasOrTuple: string | UntilTupleType, context: WorkflowContext, callable: () => Promise<false | Exclude<T, boolean>>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<Exclude<T, boolean>>;
+export declare function until<Schema extends StandardSchemaV1>(idempotencyAliasOrTuple: string | UntilTupleType, context: WorkflowContext, callable: () => Promise<false | StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare function untilPerWorkflow(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<boolean>, options?: {
-    stringify?: undefined;
-    parse?: undefined;
-    validate?: undefined;
+    schema?: undefined;
 }): Promise<void>;
-export declare function untilPerWorkflow<T>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<false | Exclude<T, boolean>>, options: {
-    stringify?: (result: T) => string;
-    parse: (value: string) => T;
-    validate?: undefined;
-} | {
-    stringify?: (result: T) => string;
-    parse?: undefined;
-    validate: (result: T) => boolean;
-}): Promise<Exclude<T, boolean>>;
-export declare function untilChanges<T>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<T>, options: {
-    equals: (previous: T, current: T) => boolean;
-    stringify?: (result: T) => string;
-    parse?: (value: string) => T;
-    validate?: (result: T) => boolean;
-}): Promise<T>;
+export declare function untilPerWorkflow<Schema extends StandardSchemaV1>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<false | StandardSchemaV1.InferInput<Schema>>, options: {
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
+export declare function untilChanges<Schema extends StandardSchemaV1>(idempotencyAlias: string, context: WorkflowContext, callable: () => Promise<StandardSchemaV1.InferInput<Schema>>, { equals, schema, }: {
+    equals: (previous: StandardSchemaV1.InferOutput<Schema>, current: StandardSchemaV1.InferOutput<Schema>) => boolean;
+    schema: Schema;
+}): Promise<StandardSchemaV1.InferOutput<Schema>>;
 export declare const zod: {
     tasks: {
         TaskId: z.ZodCustom<protobuf_es.PartialMessage<tasks_pb.TaskId>, protobuf_es.PartialMessage<tasks_pb.TaskId>>;

package/index.js

@@ -9,12 +9,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Reboot_external, _ExternalContext_external, _a, _Context_external, _Context_isInternalConstructing, _Context_stateId, _Context_method, _Context_stateTypeName, _ReaderContext_kind, _WriterContext_kind, _TransactionContext_kind, _WorkflowContext_kind, _Application_servicers, _Application_tokenVerifier, _Application_express, _Application_http, _Application_servers, _Application_createExternalContext, _Application_external;
-import { auth_pb, errors_pb, protobuf_es, toCamelCase, tasks_pb, } from "@reboot-dev/reboot-api";
-import { strict as assert } from "assert";
+var _Reboot_external, _ExternalContext_external, _a, _Context_external, _Context_isInternalConstructing, _ReaderContext_kind, _WriterContext_kind, _TransactionContext_kind, _WorkflowContext_kind, _Application_servicers, _Application_tokenVerifier, _Application_express, _Application_http, _Application_servers, _Application_createExternalContext, _Application_external;
+import { assert, auth_pb, errors_pb, nodejs_pb, parse, protobuf_es, stringify, tasks_pb, toCamelCase, } from "@reboot-dev/reboot-api";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { fork } from "node:child_process";
 import { createRequire } from "node:module";
+import toobusy from "toobusy-js";
 import { z } from "zod/v4";
 import * as reboot_native from "./reboot_native.cjs";
 import { ensureError } from "./utils/errors.js";
@@ -168,80 +168,52 @@ export async function runWithContext(context, callback) {
     }, callback);
 }
 export class Context {
-    constructor(external, cancelled) {
+    constructor({ external, stateId, method, stateTypeName, callerBearerToken, cookie, appInternal, auth, cancelled, }) {
         _Context_external.set(this, void 0);
-        _Context_stateId.set(this, void 0);
-        _Context_method.set(this, void 0);
-        _Context_stateTypeName.set(this, void 0);
         if (!__classPrivateFieldGet(_a, _a, "f", _Context_isInternalConstructing)) {
             throw new TypeError("Context is not publicly constructable");
         }
         __classPrivateFieldSet(_a, _a, false, "f", _Context_isInternalConstructing);
         __classPrivateFieldSet(this, _Context_external, external, "f");
+        this.stateId = stateId;
+        // Since we are passing a 'method' from Python, it will contain the
+        // Python-style method name, so we have to convert it there.
+        this.method = toCamelCase(method);
+        this.stateTypeName = stateTypeName;
+        this.callerBearerToken = callerBearerToken;
+        this.cookie = cookie;
+        this.appInternal = appInternal;
+        this.auth = auth;
         this.cancelled = cancelled;
     }
-    static fromNativeExternal(external, kind, cancelled) {
+    static fromNativeExternal({ kind, ...options }) {
         __classPrivateFieldSet(_a, _a, true, "f", _Context_isInternalConstructing);
         if (kind === "reader") {
-            return new ReaderContext(external, cancelled);
+            return new ReaderContext(options);
         }
         else if (kind === "writer") {
-            return new WriterContext(external, cancelled);
+            return new WriterContext(options);
         }
         else if (kind === "transaction") {
-            return new TransactionContext(external, cancelled);
+            return new TransactionContext(options);
         }
         else if (kind === "workflow") {
-            return new WorkflowContext(external, cancelled);
+            return new WorkflowContext(options);
         }
         throw new Error("Unknown method kind");
     }
     get __external() {
         return __classPrivateFieldGet(this, _Context_external, "f");
     }
-    get auth() {
-        const authBytes = reboot_native.Context_auth(__classPrivateFieldGet(this, _Context_external, "f"));
-        if (authBytes) {
-            return Auth.fromProtoBytes(authBytes);
-        }
-        return null;
-    }
-    get stateId() {
-        if (__classPrivateFieldGet(this, _Context_stateId, "f") === undefined) {
-            __classPrivateFieldSet(this, _Context_stateId, reboot_native.Context_stateId(__classPrivateFieldGet(this, _Context_external, "f")), "f");
-        }
-        return __classPrivateFieldGet(this, _Context_stateId, "f");
-    }
-    get stateTypeName() {
-        if (__classPrivateFieldGet(this, _Context_stateTypeName, "f") === undefined) {
-            __classPrivateFieldSet(this, _Context_stateTypeName, reboot_native.Context_stateTypeName(__classPrivateFieldGet(this, _Context_external, "f")), "f");
-        }
-        return __classPrivateFieldGet(this, _Context_stateTypeName, "f");
-    }
-    get method() {
-        if (__classPrivateFieldGet(this, _Context_method, "f") === undefined) {
-            __classPrivateFieldSet(this, _Context_method, toCamelCase(reboot_native.Context_method(__classPrivateFieldGet(this, _Context_external, "f"))), "f");
-        }
-        return __classPrivateFieldGet(this, _Context_method, "f");
-    }
-    get callerBearerToken() {
-        return reboot_native.Context_callerBearerToken(__classPrivateFieldGet(this, _Context_external, "f"));
-    }
-    get cookie() {
-        return reboot_native.Context_cookie(__classPrivateFieldGet(this, _Context_external, "f"));
-    }
-    get appInternal() {
-        return reboot_native.Context_appInternal(__classPrivateFieldGet(this, _Context_external, "f"));
-    }
     async generateIdempotentStateId(stateType, serviceName, method, idempotency) {
         return reboot_native.Context_generateIdempotentStateId(__classPrivateFieldGet(this, _Context_external, "f"), stateType, serviceName, method, idempotency);
     }
 }
-_a = Context, _Context_external = new WeakMap(), _Context_stateId = new WeakMap(), _Context_method = new WeakMap(), _Context_stateTypeName = new WeakMap();
+_a = Context, _Context_external = new WeakMap();
 _Context_isInternalConstructing = { value: false };
 export class ReaderContext extends Context {
-    constructor(external, cancelled) {
-        super(external, cancelled);
+    constructor(options) {
+        super(options);
         // Property helps `tsc` not treat a `ReaderContext` as any other
         // context type that structurally looks equivalent.
         _ReaderContext_kind.set(this, "reader");
@@ -249,8 +221,8 @@ export class ReaderContext extends Context {
 }
 _ReaderContext_kind = new WeakMap();
 export class WriterContext extends Context {
-    constructor(external, cancelled) {
-        super(external, cancelled);
+    constructor(options) {
+        super(options);
         // Property helps `tsc` not treat a `WriterContext` as any other
         // context type that structurally looks equivalent.
         _WriterContext_kind.set(this, "writer");
@@ -268,13 +240,14 @@ export class WriterContext extends Context {
     //   3. The writer is _not_ within a transaction.
     //   4. The writer is _not_ running as a task.
     set sync(sync) {
+        // TODO: optimize this so that we don't block the event loop.
         reboot_native.WriterContext_set_sync(this.__external, sync);
     }
 }
 _WriterContext_kind = new WeakMap();
 export class TransactionContext extends Context {
-    constructor(external, cancelled) {
-        super(external, cancelled);
+    constructor(options) {
+        super(options);
         // Property helps `tsc` not treat a `TransactionContext` as any other
         // context type that structurally looks equivalent.
         _TransactionContext_kind.set(this, "transaction");
@@ -282,8 +255,8 @@ export class TransactionContext extends Context {
 }
 _TransactionContext_kind = new WeakMap();
 export class WorkflowContext extends Context {
-    constructor(external, cancelled) {
-        super(external, cancelled);
+    constructor(options) {
+        super(options);
         // Property helps `tsc` not treat a `WorkflowContext` as any other
         // context type that structurally looks equivalent.
         _WorkflowContext_kind.set(this, "workflow");
@@ -398,8 +371,21 @@ export class Auth {
  * Bearer` token when passed and optionally extract token metadata.
  */
 export class TokenVerifier {
-    async _verifyToken(context, token) {
-        const auth = await this.verifyToken(context, token);
+    async _verifyToken(external, cancelled, bytesCall) {
+        const call = nodejs_pb.VerifyTokenCall.fromBinary(bytesCall);
+        const context = Context.fromNativeExternal({
+            external,
+            kind: "reader",
+            stateId: call.context.stateId,
+            method: call.context.method,
+            stateTypeName: call.context.stateTypeName,
+            callerBearerToken: call.context.callerBearerToken,
+            cookie: call.context.cookie,
+            appInternal: call.context.appInternal,
+            auth: null,
+            cancelled,
+        });
+        const auth = await this.verifyToken(context, call.token);
         if (!auth) {
             return null;
         }
@@ -617,6 +603,14 @@ export class Application {
         return __classPrivateFieldGet(this, _Application_http, "f");
     }
     async run() {
+        if (process.env.REBOOT_ENABLE_EVENT_LOOP_LAG_MONITORING === "true") {
+            toobusy.onLag((lag) => {
+                console.log(`Node.js event loop lag detected! Latency: ${lag}ms.
+          This may indicate a blocking operation on the main thread
+          (e.g., CPU-intensive task). If you are not running such tasks,
+          please report this issue to the maintainers.`);
+            });
+        }
         return await reboot_native.Application_run(__classPrivateFieldGet(this, _Application_external, "f"));
     }
     get __external() {
@@ -731,9 +725,7 @@ export async function retryReactivelyUntil(context, condition) {
 export const ALWAYS = "ALWAYS";
 export const PER_WORKFLOW = "PER_WORKFLOW";
 export const PER_ITERATION = "PER_ITERATION";
-async function memoize(idempotencyAliasOrTuple, context, callable, { stringify = JSON.stringify, parse = JSON.parse, validate, atMostOnce, until = false, }) {
-    assert(stringify !== undefined);
-    assert(parse !== undefined);
+async function memoize(idempotencyAliasOrTuple, context, callable, { schema, atMostOnce, until = false, }) {
     assert(atMostOnce !== undefined);
     if (!(typeof idempotencyAliasOrTuple === "string" ||
         (Array.isArray(idempotencyAliasOrTuple) &&
@@ -749,27 +741,38 @@ async function memoize(idempotencyAliasOrTuple, context, callable, { stringify =
         try {
             const t = await callable();
             if (t !== undefined) {
-                if (validate === undefined) {
-                    // TODO: link to docs about why this is required, when those docs exist.
-                    throw new Error(`Result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' is not 'boolean' but 'validate' option is undefined`);
+                // Fail early if the developer forgot to pass `schema`.
+                if (schema === undefined) {
+                    throw new Error(`Expecting 'schema' as you are returning a value from the function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}'`);
+                }
+                let validate = schema["~standard"].validate(t);
+                if (validate instanceof Promise) {
+                    validate = await validate;
                 }
-                else if (!validate(t)) {
-                    throw new Error(`Calling 'validate' on result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' returned 'false'`);
+                // If the `issues` field exists, the validation failed.
+                if (validate.issues) {
+                    throw new Error(`Failed to validate result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}': ${JSON.stringify(validate.issues, null, 2)}`);
                 }
+                // We use `stringify` from `@reboot-dev/reboot-api` because
+                // it can handle `BigInt` and `Uint8Array` which are common
+                // types from protobuf.
+                //
                 // NOTE: to differentiate `callable` returning `void` (or
-                // explicitly `undefined`) from `stringify` returning an empty
-                // string we use `{ value: stringify(t) }`.
-                const result = { value: stringify(t) };
-                return JSON.stringify(result);
+                // explicitly `undefined`) from `stringify` returning
+                // an empty string we use `{ value: t }`.
+                const result = { value: t };
+                return stringify(result);
             }
-            // Fail early if the developer thinks that they have some value
-            // that they want to validate but we got `undefined`.
-            if (validate !== undefined) {
-                throw new Error("Not expecting `validate` as you are returning `void` (or explicitly `undefined`); did you mean to return a value (or if you want to explicitly return the absence of a value use `null`)");
+            else {
+                // Fail early if the developer thinks that they have some
+                // value that they want to validate but we got `undefined`.
+                if (schema !== undefined) {
+                    throw new Error(`Not expecting 'schema' as you are returning 'void' (or explicitly 'undefined') from the function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' ; did you mean to return a value (or if you want to explicitly return the absence of a value use 'null')`);
+                }
+                // NOTE: using the empty string to represent a `callable`
+                // returning `void` (or explicitly `undefined`).
+                return "";
             }
-            // NOTE: using the empty string to represent a `callable`
-            // returning `void` (or explicitly `undefined`).
-            return "";
         }
         catch (e) {
             const error = ensureError(e);
@@ -787,22 +790,27 @@ async function memoize(idempotencyAliasOrTuple, context, callable, { stringify =
     // instead of the `parse` and `validate` properties we use here).
     assert(result !== undefined);
     if (result !== "") {
-        const { value } = JSON.parse(result);
-        const t = parse(value);
-        if (parse !== JSON.parse) {
-            if (validate === undefined) {
-                throw new Error(`Result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' is not 'boolean' but 'validate' option is undefined`);
-            }
-            else if (!validate(t)) {
-                throw new Error(`Calling 'validate' on result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' returned 'false'`);
-            }
+        // We use `parse` from `@reboot-dev/reboot-api` because it can
+        // handle `BigInt` and `Uint8Array` which are common types from
+        // protobuf.
+        const { value } = parse(result);
+        if (schema === undefined) {
+            throw new Error(`Expecting 'schema' as we have already memoized a result for the function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}' has the code been updated to remove a previously existing 'schema'`);
+        }
+        let validate = schema["~standard"].validate(value);
+        if (validate instanceof Promise) {
+            validate = await validate;
+        }
+        // If the `issues` field exists, the validation failed.
+        if (validate.issues) {
+            throw new Error(`Failed to validate result of function passed to '${atMostOnce ? "atMostOnce" : until ? "until" : "atLeastOnce"}': ${JSON.stringify(validate.issues, null, 2)}`);
         }
-        return t;
+        return validate.value;
     }
     // Otherwise `callable` must have returned void (or explicitly
     // `undefined`), fall through.
 }
-export async function atMostOnce(idempotencyAliasOrTuple, context, callable, options = { validate: undefined }) {
+export async function atMostOnce(idempotencyAliasOrTuple, context, callable, options = {}) {
     try {
         return await memoize(idempotencyAliasOrTuple, context, callable, {
             ...options,
@@ -816,19 +824,19 @@ export async function atMostOnce(idempotencyAliasOrTuple, context, callable, opt
         throw e;
     }
 }
-export async function atMostOncePerWorkflow(idempotencyAlias, context, callable, options = { validate: undefined }) {
+export async function atMostOncePerWorkflow(idempotencyAlias, context, callable, options = {}) {
     return atMostOnce([idempotencyAlias, PER_WORKFLOW], context, callable, options);
 }
-export async function atLeastOnce(idempotencyAliasOrTuple, context, callable, options = { validate: undefined }) {
+export async function atLeastOnce(idempotencyAliasOrTuple, context, callable, options = {}) {
     return memoize(idempotencyAliasOrTuple, context, callable, {
         ...options,
         atMostOnce: false,
     });
 }
-export async function atLeastOncePerWorkflow(idempotencyAlias, context, callable, options = { validate: undefined }) {
+export async function atLeastOncePerWorkflow(idempotencyAlias, context, callable, options = {}) {
     return await atLeastOnce([idempotencyAlias, PER_WORKFLOW], context, callable, options);
 }
-export async function until(idempotencyAliasOrTuple, context, callable, options = { validate: undefined }) {
+export async function until(idempotencyAliasOrTuple, context, callable, options = {}) {
     // TODO(benh): figure out how to not use `as` type assertions here
     // to appease the TypeScript compiler which otherwise isn't happy
     // with passing on these types.
@@ -843,26 +851,25 @@ export async function until(idempotencyAliasOrTuple, context, callable, options
         until: true,
     });
 }
-export async function untilPerWorkflow(idempotencyAlias, context, callable, options = { validate: undefined }) {
+export async function untilPerWorkflow(idempotencyAlias, context, callable, options = {}) {
     return await until([idempotencyAlias, PER_WORKFLOW], context, callable, options);
 }
-export async function untilChanges(idempotencyAlias, context, callable, options) {
+export async function untilChanges(idempotencyAlias, context, callable, { equals, schema, }) {
     const iteration = getLoopIteration();
     if (iteration === undefined) {
         throw new Error("Waiting for changes must be done _within_ a control loop");
     }
-    if (options.equals === undefined) {
+    if (equals === undefined) {
         // TODO: don't make `equals` required, instead use one of the
         // various libraries that does deep equality.
         throw new Error("Missing 'equals' option");
     }
-    const { equals, ...optionsWithoutEquals } = options;
     let previous = null;
     if (iteration > 0) {
         // Get the previous memoized result!
         previous = (await untilPerWorkflow(`${idempotencyAlias} #${iteration - 1}`, context, (async () => {
             throw new Error(`Missing memoized value for '${idempotencyAlias}'`);
-        }), optionsWithoutEquals));
+        }), { schema }));
     }
     // Wait until previous result does not equal current result.
     return (await untilPerWorkflow(`${idempotencyAlias} #${iteration}`, context, (async () => {
@@ -875,7 +882,7 @@ export async function untilChanges(idempotencyAlias, context, callable, options)
             return current;
         }
         return false;
-    }), optionsWithoutEquals));
+    }), { schema }));
 }
 const launchSubprocessConsensus = (base64_args) => {
     // Create a child process via `fork` (which does not mean `fork` as
@@ -897,7 +904,7 @@ const callback = (...args) => {
     console.log(new Date(), ...args);
 };
 ensurePythonVenv();
-reboot_native.initialize(callback, Context.fromNativeExternal, launchSubprocessConsensus);
+reboot_native.initialize(callback, launchSubprocessConsensus);
 // TODO: move these into @reboot-dev/reboot-api and also generate them
 // via plugin, perhaps via a new plugin which emits the Zod schemas
 // for all protobuf messages, which might be easier after we've moved

package/package.json

@@ -3,7 +3,7 @@
     "@bufbuild/protobuf": "1.3.2",
     "@bufbuild/protoplugin": "1.3.2",
     "@bufbuild/protoc-gen-es": "1.3.2",
-    "@reboot-dev/reboot-api": "0.33.1",
+    "@reboot-dev/reboot-api": "0.35.0",
     "chalk": "^4.1.2",
     "node-addon-api": "^7.0.0",
     "node-gyp": ">=10.2.0",
@@ -14,11 +14,13 @@
     "express": "^5.1.0",
     "@scarf/scarf": "1.4.0",
     "tsx": "^4.19.2",
-    "zod": "^3.25.51"
+    "zod": "^3.25.51",
+    "toobusy-js": "^0.5.1",
+    "@standard-schema/spec": "1.0.0"
   },
   "type": "module",
   "name": "@reboot-dev/reboot",
-  "version": "0.33.1",
+  "version": "0.35.0",
   "description": "npm package for Reboot",
   "scripts": {
     "preinstall": "node preinstall.cjs",