two-stroke 7.11.4 → 7.11.5

package/package.json

@@ -10,18 +10,18 @@
     "type-check": "./bin/type-check.mjs"
   },
   "dependencies": {
-    "@cloudflare/vitest-pool-workers": "^0.18.8",
+    "@cloudflare/vitest-pool-workers": "^0.21.3",
     "@sentry/cli": "^3.6.2",
-    "@typescript-eslint/eslint-plugin": "^8.65.0",
-    "@typescript-eslint/parser": "^8.65.0",
-    "@vitest/runner": "^4.1.8",
-    "@vitest/snapshot": "^4.1.8",
+    "@typescript-eslint/eslint-plugin": "^8.67.0",
+    "@typescript-eslint/parser": "^8.67.0",
+    "@vitest/runner": "^4.1.10",
+    "@vitest/snapshot": "^4.1.10",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-config-two-stroke": "^1.5.9",
+    "eslint-config-two-stroke": "^1.5.10",
     "eslint-config-typescript": "^3.0.0",
-    "jose": "^6.2.4",
+    "jose": "^6.2.8",
     "mime": "^4.1.0",
-    "miniflare": "^4.20260722.0",
+    "miniflare": "5.20260811.1-alpha",
     "msw": "^2.14.6",
     "openapi-fetch": "^0.17.0",
     "openapi-typescript": "^7.13.0",
@@ -56,10 +56,10 @@
     "url": "https://github.com/change-engine/two-stroke"
   },
   "type": "module",
-  "version": "7.11.4",
+  "version": "7.11.5",
   "devDependencies": {
     "@types/eslint": "^9.6.1",
-    "eslint": "^10.8.0",
+    "eslint": "^10.8.1",
     "prettier": "^3.9.6",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10"

package/worker-configuration.d.ts

@@ -1,16 +1,9 @@
 /* eslint-disable */
-// Generated by Wrangler by running `wrangler types` (hash: 257ab1035028648fc82c85d44bb6571e)
-// Runtime types generated with workerd@1.20260708.1 2025-09-15 disable_nodejs_fs_module,nodejs_compat
+// Generated by Wrangler by running `wrangler types` (hash: a586733b457304f7909e3b75aa9b2082)
+// Runtime types generated with workerd@1.20260811.1 2025-09-15 disable_nodejs_fs_module,nodejs_compat
 interface __BaseEnv_Env {
-	KINESIS_STREAM_NAME_V2: string;
-	LABS_PRIVATE_KEY: string;
-	SENTRY_DSN: string;
-	SENTRY_ENVIRONMENT: string;
-	SENTRY_TRACES_SAMPLE_RATE: string;
-	SLACK_SUPABASE_PUBLIC_KEY: string;
-	TOKEN_AUDIENCE: string;
-	TOKEN_HASH: string;
-	TOKEN_ISSUER: string;
+	TOKEN_ISSUER: "fake";
+	TOKEN_AUDIENCE: "fake";
 }
 declare namespace Cloudflare {
 	interface GlobalProps {
@@ -23,7 +16,7 @@ type StringifyValues<EnvType extends Record<string, unknown>> = {
 	[Binding in keyof EnvType]: EnvType[Binding] extends string ? EnvType[Binding] : string;
 };
 declare namespace NodeJS {
-	interface ProcessEnv extends StringifyValues<Pick<Cloudflare.Env, "KINESIS_STREAM_NAME_V2" | "LABS_PRIVATE_KEY" | "SENTRY_DSN" | "SENTRY_ENVIRONMENT" | "SENTRY_TRACES_SAMPLE_RATE" | "SLACK_SUPABASE_PUBLIC_KEY" | "TOKEN_AUDIENCE" | "TOKEN_HASH" | "TOKEN_ISSUER">> {}
+	interface ProcessEnv extends StringifyValues<Pick<Cloudflare.Env, "TOKEN_ISSUER" | "TOKEN_AUDIENCE">> {}
 }
 
 // Begin runtime types
@@ -450,6 +443,7 @@ interface ExecutionContext<Props = unknown> {
     cache?: CacheContext;
     readonly access?: CloudflareAccessContext;
     tracing: Tracing;
+    abort(reason?: any): void;
 }
 type ExportedHandlerFetchHandler<Env = unknown, CfHostMetadata = unknown, Props = unknown> = (request: Request<CfHostMetadata, IncomingRequestCfProperties<CfHostMetadata>>, env: Env, ctx: ExecutionContext<Props>) => Response | Promise<Response>;
 type ExportedHandlerConnectHandler<Env = unknown, Props = unknown> = (socket: Socket, env: Env, ctx: ExecutionContext<Props>) => void | Promise<void>;
@@ -2782,6 +2776,12 @@ interface TraceLog {
     readonly timestamp: number;
     readonly level: string;
     readonly message: any;
+    readonly errorInfo?: (TraceLogErrorInfo | null)[];
+}
+interface TraceLogErrorInfo {
+    name: string;
+    message: string;
+    stack?: string;
 }
 interface TraceException {
     readonly timestamp: number;
@@ -3322,18 +3322,26 @@ interface ContainerExecOptions {
     cwd?: string;
     env?: Record<string, string>;
     user?: string;
+    signal?: AbortSignal;
+    pty?: boolean | ContainerExecPtyOptions;
     stdin?: ReadableStream | "pipe";
     stdout?: "pipe" | "ignore";
     stderr?: "pipe" | "ignore" | "combined";
 }
+interface ContainerExecPtyOptions {
+    cols?: number;
+    rows?: number;
+}
 interface ExecProcess {
     readonly stdin: WritableStream | null;
     readonly stdout: ReadableStream | null;
     readonly stderr: ReadableStream | null;
     readonly pid: number;
+    readonly isPty: boolean;
     readonly exitCode: Promise<number>;
     output(): Promise<ExecOutput>;
     kill(signal?: number): void;
+    resize(cols: number, rows: number): void;
 }
 interface Container {
     get running(): boolean;
@@ -3380,6 +3388,11 @@ interface ContainerStartupOptions {
     directorySnapshots?: ContainerDirectorySnapshotRestoreParams[];
     containerSnapshot?: ContainerSnapshot;
 }
+interface ContainerStartResources {
+    vcpu: number;
+    memoryMib: number;
+    diskMb: number;
+}
 /**
  * The **`MessagePort`** interface of the Channel Messaging API represents one of the two ports of a MessageChannel, allowing messages to be sent from one port and listening out for them arriving at the other.
  *
@@ -3520,11 +3533,13 @@ declare abstract class Performance {
 interface Tracing {
     enterSpan<T, A extends unknown[]>(name: string, callback: (span: Span, ...args: A) => T, ...args: A): T;
     startActiveSpan<T, A extends unknown[]>(name: string, callback: (span: Span, ...args: A) => T, ...args: A): T;
+    startSpan(name: string): Span;
     Span: typeof Span;
 }
 declare abstract class Span {
     get isTraced(): boolean;
-    setAttribute(key: string, value?: (boolean | number | string)): void;
+    setAttribute(key: string, value: boolean | number | string): this;
+    setAttributes(attributes: Record<string, boolean | number | string | undefined>): this;
     end(): void;
 }
 /**
@@ -4164,6 +4179,13 @@ type AiSearchListItemsParams = {
     source?: string;
     /** JSON-encoded Vectorize filter for metadata filtering. */
     metadata_filter?: string;
+    /** Filter items by their unique ID. Returns at most one item. */
+    item_id?: string;
+    /**
+     * Filter items by their exact key (object key / filename). Keys are unique
+     * per source, so combine with `source` to disambiguate across data sources.
+     */
+    key?: string;
 };
 type AiSearchListItemsResponse = {
     result: AiSearchItemInfo[];
@@ -12452,6 +12474,15 @@ interface Hyperdrive {
      * for your database.
      */
     readonly host: string;
+    /*
+     * A synthetic IPv4 address (in the reserved 240.0.0.0/4 range) that, like the
+     * host field, is only valid within the context of the currently running
+     * Worker and, when passed into the `connect()` function from the
+     * "cloudflare:sockets" module, will connect to the Hyperdrive instance for
+     * your database. This is provided for database drivers that require the host
+     * to be an IP literal rather than a hostname.
+     */
+    readonly ip: string;
     /*
      * The port that must be paired the the host field when connecting.
      */
@@ -13138,6 +13169,26 @@ declare namespace CloudflareWorkersModule {
         timeout?: WorkflowTimeoutDuration | number;
         sensitive?: WorkflowStepSensitivity;
     };
+    // Internal discriminators used only for `WorkflowStep.do` overload
+    // resolution. They mirror `WorkflowStepConfig` but pin `retries.delay` to a
+    // single kind so the callback context can be narrowed based on the shape of
+    // the config argument (rather than on an inferred type parameter, which is
+    // lost when the caller supplies an explicit return-type argument). Not
+    // exported: they must not widen the public type surface.
+    type WorkflowStepConfigWithStaticDelay = Omit<WorkflowStepConfig, 'retries'> & {
+        retries?: {
+            limit: number;
+            delay: WorkflowDelayDuration | number;
+            backoff?: WorkflowBackoff;
+        };
+    };
+    type WorkflowStepConfigWithDelayFunction = Omit<WorkflowStepConfig, 'retries'> & {
+        retries: {
+            limit: number;
+            delay: WorkflowDelayFunction;
+            backoff?: WorkflowBackoff;
+        };
+    };
     export type WorkflowStepRollbackConfig = Pick<WorkflowStepConfig, 'retries' | 'timeout'>;
     export type WorkflowCronSchedule = {
         /** Cron expression that triggered this event. */
@@ -13175,23 +13226,35 @@ declare namespace CloudflareWorkersModule {
             sensitive?: WorkflowStepSensitivity;
         };
     };
-    export type WorkflowRollbackContext<T = unknown> = {
-        ctx: WorkflowStepContext;
+    // The rollback handler receives the step context, so it mirrors the same
+    // delay discriminant as the step callback: when the step was configured with
+    // a dynamic delay function the resolved `config.retries.delay` is omitted,
+    // otherwise it is present. `Delay` is threaded from the `WorkflowStep.do`
+    // overload that matched the step config.
+    export type WorkflowRollbackContext<T = unknown, Delay = WorkflowDelayDuration | number> = {
+        ctx: WorkflowStepContext<Delay>;
         error: Error;
         output: T | undefined;
         /** @deprecated Use `ctx.step.name` and `ctx.step.count` instead. */
         stepName: string;
     };
-    export type WorkflowRollbackHandler<T = unknown> = (ctx: WorkflowRollbackContext<T>) => Promise<void>;
-    export type WorkflowStepRollbackOptions<T = unknown> = {
-        rollback: WorkflowRollbackHandler<T>;
+    export type WorkflowRollbackHandler<T = unknown, Delay = WorkflowDelayDuration | number> = (ctx: WorkflowRollbackContext<T, Delay>) => Promise<void>;
+    export type WorkflowStepRollbackOptions<T = unknown, Delay = WorkflowDelayDuration | number> = {
+        rollback: WorkflowRollbackHandler<T, Delay>;
         rollbackConfig?: WorkflowStepRollbackConfig;
     };
     export abstract class WorkflowStep {
         do<T extends Rpc.Serializable<T>>(name: string, callback: (ctx: WorkflowStepContext) => Promise<T>, rollbackOptions?: WorkflowStepRollbackOptions<T>): Promise<T>;
-        do<T extends Rpc.Serializable<T>, const C extends WorkflowStepConfig>(name: string, config: C, callback: (ctx: WorkflowStepContext<C['retries'] extends {
-            delay: infer D;
-        } ? D : WorkflowDelayDuration | number>) => Promise<T>, rollbackOptions?: WorkflowStepRollbackOptions<T>): Promise<T>;
+        // The config overloads discriminate on the shape of `config.retries.delay`
+        // so the callback context reflects whether the resolved delay is present
+        // (static delay) or omitted (dynamic delay function). Each has a single
+        // type parameter, so an explicit return-type argument (`do<T>(...)`) still
+        // resolves here. ORDERING IS LOAD-BEARING: the broad `WorkflowStepConfig`
+        // fallback MUST remain last, otherwise it shadows the discriminating
+        // overloads and narrowing is silently lost.
+        do<T extends Rpc.Serializable<T>>(name: string, config: WorkflowStepConfigWithDelayFunction, callback: (ctx: WorkflowStepContext<WorkflowDelayFunction>) => Promise<T>, rollbackOptions?: WorkflowStepRollbackOptions<T, WorkflowDelayFunction>): Promise<T>;
+        do<T extends Rpc.Serializable<T>>(name: string, config: WorkflowStepConfigWithStaticDelay, callback: (ctx: WorkflowStepContext<WorkflowDelayDuration | number>) => Promise<T>, rollbackOptions?: WorkflowStepRollbackOptions<T, WorkflowDelayDuration | number>): Promise<T>;
+        do<T extends Rpc.Serializable<T>>(name: string, config: WorkflowStepConfig, callback: (ctx: WorkflowStepContext) => Promise<T>, rollbackOptions?: WorkflowStepRollbackOptions<T>): Promise<T>;
         sleep: (name: string, duration: WorkflowSleepDuration) => Promise<void>;
         sleepUntil: (name: string, timestamp: Date | number) => Promise<void>;
         waitForEvent<T extends Rpc.Serializable<T>>(name: string, options: {
@@ -13966,11 +14029,12 @@ type MarkdownDocument = {
     name: string;
     blob: Blob;
 };
+type OutputFormat = 'markdown' | 'text';
 type ConversionResponse = {
     id: string;
     name: string;
     mimeType: string;
-    format: 'markdown';
+    format: OutputFormat;
     tokens: number;
     data: string;
 } | {
@@ -13987,7 +14051,11 @@ type EmbeddedImageConversionOptions = ImageConversionOptions & {
     convert?: boolean;
     maxConvertedImages?: number;
 };
+type ConversionOutputOptions = {
+    format?: OutputFormat;
+};
 type ConversionOptions = {
+    output?: ConversionOutputOptions;
     html?: {
         images?: EmbeddedImageConversionOptions & {
             convertOGImage?: boolean;
@@ -14136,11 +14204,22 @@ declare namespace TailStream {
         readonly message: string;
         readonly stack?: string;
     }
-    interface Log {
+    interface TailStreamErrorInfo {
+        readonly name: string;
+        readonly message: string;
+        readonly stack?: string;
+    }
+    type Log = {
         readonly type: "log";
         readonly level: "debug" | "error" | "info" | "log" | "warn";
+        readonly errorInfo?: readonly (TailStreamErrorInfo | null)[];
+    } & ({
         readonly message: object;
-    }
+        readonly truncated?: false;
+    } | {
+        readonly message: string;
+        readonly truncated: true;
+    });
     interface DroppedEventsDiagnostic {
         readonly diagnosticsType: "droppedEvents";
         readonly count: number;
@@ -14618,7 +14697,25 @@ declare abstract class Workflow<PARAMS = unknown> {
      * @returns A promise that resolves with a list of handles for the created instances.
      */
     public createBatch(batch: WorkflowInstanceCreateOptions<PARAMS>[]): Promise<WorkflowInstance[]>;
+    /**
+     * Delete a batch of Workflow instances and their stored state.
+     * `deleteBatch` is limited to 100 instances at a time. Duplicate IDs are deleted once.
+     * The result contains one entry for each input position; IDs that do not exist are returned as per-instance errors.
+     * @param instanceIds IDs of the Workflow instances to delete
+     * @returns A promise that resolves with the successfully deleted instances and any per-instance errors.
+     */
+    public deleteBatch(instanceIds: string[]): Promise<WorkflowBatchDeleteResult>;
 }
+type WorkflowBatchDeleteResult = {
+    deleted: {
+        id: string;
+    }[];
+    errors: {
+        id: string;
+        code: number;
+        message: string;
+    }[];
+};
 type WorkflowDurationLabel = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
 type WorkflowSleepDuration = `${number} ${WorkflowDurationLabel}${'s' | ''}` | number;
 type WorkflowRetentionDuration = WorkflowSleepDuration;
@@ -14705,6 +14802,10 @@ declare abstract class WorkflowInstance {
      * @param options Options for the restart, including an optional step to restart from.
      */
     public restart(options?: WorkflowInstanceRestartOptions): Promise<void>;
+    /**
+     * Delete the instance and its stored state.
+     */
+    public delete(): Promise<void>;
     /**
      * Returns the current status of the instance.
      */