@typfolio/workers 0.1.0 → 0.2.0

package/dist/batch.js

@@ -2,6 +2,16 @@ import * as Effect from 'effect/Effect';
 import * as Stream from 'effect/Stream';
 import { snapshotRequest } from './snapshot.js';
 import { TypfolioWorkerError, } from './types.js';
+function capture(job, index) {
+    try {
+        return { id: job.id, index, request: snapshotRequest(job.request), timeoutMs: job.timeoutMs };
+    }
+    catch (error) {
+        if (error instanceof TypfolioWorkerError && error.code === 'INVALID_INPUT')
+            return { id: job.id, index, rejected: error };
+        throw error;
+    }
+}
 function cancelled(job) {
     return { id: job.id, index: job.index, status: 'cancelled' };
 }
@@ -13,6 +23,9 @@ function normalizeError(error) {
 const run = Effect.fnUntraced(function* (client, job, batchSignal) {
     if (batchSignal?.aborted)
         return cancelled(job);
+    if (job.request === undefined)
+        return { id: job.id, index: job.index, status: 'error', error: job.rejected };
+    const request = job.request;
     return yield* Effect.tryPromise({
         try: effectSignal => {
             const controller = new AbortController();
@@ -24,7 +37,7 @@ const run = Effect.fnUntraced(function* (client, job, batchSignal) {
                 abortFromEffect();
             if (batchSignal?.aborted)
                 abortFromBatch();
-            return client.compile(job.request, {
+            return client.compile(request, {
                 signal: controller.signal,
                 timeoutMs: job.timeoutMs,
             }).finally(() => {
@@ -63,12 +76,7 @@ function advance(progress, outcome) {
  * Events are yielded in completion order and results are not retained here.
  */
 export function compileBatch(client, jobs, options = {}) {
-    const captured = jobs.map((job, index) => ({
-        id: job.id,
-        index,
-        request: snapshotRequest(job.request),
-        timeoutMs: job.timeoutMs,
-    }));
+    const captured = jobs.map(capture);
     return (async function* stream() {
         let progress = initialProgress(captured.length);
         options.onProgress?.(progress);

package/dist/index.js

@@ -2,7 +2,7 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as ManagedRuntime from 'effect/ManagedRuntime';
 import { decodeRuntimeMessage, protocolVersion } from './protocol.js';
-import { isSnapshot, snapshotRequest, transferableBuffers } from './snapshot.js';
+import { isSnapshot, snapshotRequest, snapshotValidation, transferableBuffers } from './snapshot.js';
 import { TypfolioWorkerError, } from './types.js';
 export { TypfolioWorkerError, } from './types.js';
 export { collectBatch, compileBatch } from './batch.js';
@@ -283,6 +283,11 @@ export function createWorkerClient(options) {
                 return Promise.reject(error);
             }
             let program = compileJob(captured);
+            const validation = snapshotValidation(captured);
+            if (validation) {
+                const checked = captured;
+                program = Effect.flatMap(Effect.tryPromise({ try: () => validation, catch: error => error }), () => compileJob(checked));
+            }
             if (duration !== undefined) {
                 program = Effect.timeoutOrElse(program, {
                     duration,

package/dist/protocol.js

@@ -44,6 +44,9 @@ function diagnostic(value) {
         path: typeof item.path === 'string' ? item.path : undefined,
         range: typeof item.range === 'string' ? item.range : undefined,
         package: typeof item.package === 'string' ? item.package : undefined,
+        ...(typeof item.code === 'string' ? { code: item.code } : {}),
+        ...(typeof item.file === 'string' ? { file: item.file } : {}),
+        ...(typeof item.text === 'string' ? { text: item.text } : {}),
     };
 }
 function serializedError(value) {
@@ -52,7 +55,7 @@ function serializedError(value) {
         throw new TypeError('Invalid worker error');
     }
     const codes = [
-        'INITIALIZATION', 'INVALID_REQUEST', 'UNSUPPORTED_OPTION', 'BUSY', 'DISPOSED',
+        'INITIALIZATION', 'INVALID_REQUEST', 'INVALID_INPUT', 'UNSUPPORTED_OPTION', 'BUSY', 'DISPOSED',
         'ABORTED', 'COMPILATION', 'ENGINE', 'WORKER', 'TIMEOUT', 'QUEUE_FULL',
     ];
     const code = codes.find(candidate => candidate === error.code);

package/dist/snapshot.d.ts

@@ -1,10 +1,16 @@
-import type { PdfRequest } from '@typfolio/core';
+import { type AnyPdfRequest, type DocumentsRequest, type PdfRequest } from '@typfolio/core';
+/** The pending schema check of a snapshot, if its template's schemas validate asynchronously. */
+export declare function snapshotValidation(snapshot: object): Promise<void> | undefined;
 export declare function isSnapshot(request: unknown): boolean;
-export declare function snapshotRequest(request: PdfRequest<unknown>): PdfRequest<unknown>;
+/**
+ * A copy of the request the client owns. A request for a defined template is first checked against its
+ * schemas and turned into its low-level form (schemas are functions and cannot cross the boundary).
+ */
+export declare function snapshotRequest(request: AnyPdfRequest): PdfRequest<unknown> | DocumentsRequest;
 /**
  * The buffers of a snapshot's assets that `postMessage` can transfer, each once. Buffers that cannot be
  * transferred (a `SharedArrayBuffer`, which structured clone shares instead of copying, or one that is already
  * detached) are left out and travel by the ordinary clone. Only call this with a snapshot: transferring detaches
  * the buffers, which would break a caller's request.
  */
-export declare function transferableBuffers(snapshot: PdfRequest<unknown>): ArrayBuffer[];
+export declare function transferableBuffers(snapshot: PdfRequest<unknown> | DocumentsRequest): ArrayBuffer[];

package/dist/snapshot.js

@@ -1,3 +1,5 @@
+import { TypstPdfError } from '@typfolio/core';
+import { resolveRequest } from '@typfolio/core/internal';
 import { TypfolioWorkerError } from './types.js';
 function inspectCloneable(value, ancestors, at) {
     if (typeof value === 'function' || typeof value === 'symbol') {
@@ -28,19 +30,49 @@ function inspectCloneable(value, ancestors, at) {
 // Every request returned by snapshotRequest. The client owns these (nothing else holds their buffers), so it
 // neither snapshots them again nor hesitates to transfer them.
 const snapshots = new WeakSet();
+// A schema that validates asynchronously: its check, which the client awaits before dispatching.
+const validations = new WeakMap();
+// Errors from core (an input that fails its schema, a missing partial) as the client's own error type.
+function asWorkerError(error) {
+    return error instanceof TypstPdfError
+        ? new TypfolioWorkerError(error.code, error.message, error.diagnostics, { cause: error })
+        : error;
+}
+/** The pending schema check of a snapshot, if its template's schemas validate asynchronously. */
+export function snapshotValidation(snapshot) {
+    return validations.get(snapshot);
+}
 export function isSnapshot(request) {
     return typeof request === 'object' && request !== null && snapshots.has(request);
 }
+/**
+ * A copy of the request the client owns. A request for a defined template is first checked against its
+ * schemas and turned into its low-level form (schemas are functions and cannot cross the boundary).
+ */
 export function snapshotRequest(request) {
+    let resolved;
     try {
-        inspectCloneable(request, new Set(), 'request');
-        const snapshot = structuredClone(request);
+        resolved = resolveRequest(request);
+    }
+    catch (error) {
+        throw asWorkerError(error);
+    }
+    let snapshot;
+    try {
+        inspectCloneable(resolved.request, new Set(), 'request');
+        snapshot = structuredClone(resolved.request);
         snapshots.add(snapshot);
-        return snapshot;
     }
     catch (cause) {
         throw new TypfolioWorkerError('INVALID_REQUEST', 'The PDF request cannot cross the worker boundary', [], { cause });
     }
+    if (resolved.validated) {
+        const validation = resolved.validated.catch(error => { throw asWorkerError(error); });
+        // A batch job may wait its turn before the client awaits this: a failure is not unhandled meanwhile.
+        validation.catch(() => { });
+        validations.set(snapshot, validation);
+    }
+    return snapshot;
 }
 /**
  * The buffers of a snapshot's assets that `postMessage` can transfer, each once. Buffers that cannot be

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { Diagnostic, ErrorCode, PdfClient, PdfRequest, PdfResult } from '@typfolio/core';
+import type { AnyPdfRequest, CheckedRequest, Diagnostic, ErrorCode, PdfClient, PdfResult } from '@typfolio/core';
 /** WASM sources that the structured-clone worker protocol can carry reliably. */
 export type WorkerWasmSource = string | ArrayBuffer | Uint8Array | WebAssembly.Module;
 /**
@@ -22,7 +22,8 @@ export interface WorkerCompileOptions {
 }
 export interface PdfWorkerClient extends PdfClient {
     readonly workerCount: number;
-    compile(request: PdfRequest<unknown>, options?: WorkerCompileOptions): Promise<PdfResult>;
+    /** A plain request, or one for a defined template: its inputs are checked against their schemas on this thread. */
+    compile<R extends AnyPdfRequest>(request: R & CheckedRequest<R>, options?: WorkerCompileOptions): Promise<PdfResult>;
     /** Rejects queued/active jobs and terminates all owned workers. Idempotent. */
     dispose(): Promise<void>;
 }
@@ -41,7 +42,7 @@ export interface CreateWorkerClientOptions {
 }
 export interface PdfBatchJob<Id> {
     readonly id: Id;
-    readonly request: PdfRequest<unknown>;
+    readonly request: AnyPdfRequest;
     readonly timeoutMs?: number;
 }
 export type PdfBatchOutcome<Id> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typfolio/workers",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Framework-independent Web Worker execution for Typfolio PDF compilation",
   "type": "module",
   "license": "Apache-2.0",
@@ -16,6 +16,7 @@
     "dist",
     "README.md"
   ],
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -24,7 +25,7 @@
     "./runtime": "./dist/runtime.js"
   },
   "dependencies": {
-    "@typfolio/core": "^0.1.0",
+    "@typfolio/core": "^0.2.0",
     "effect": "4.0.0-rc.118"
   },
   "publishConfig": {