@deepseek-ai/dsh-typert-generator 0.2.1-alpha.2 → 0.2.1-alpha.3

package/lib/types/model.d.ts

@@ -95,9 +95,10 @@ export interface InvocationParameterModel {
     /** Authored as an optional parameter, so consumers may omit the wire field. */
     readonly optional?: true;
     readonly boundary: RemoteBoundaryModel;
+    readonly description?: string;
 }
 /** One strictly analyzed Host method exported through Typert Gateway. */
-export interface InvocationModel {
+export interface InvocationModel extends DocumentationModel {
     readonly id: string;
     readonly service: string;
     readonly namespace: string;
@@ -302,7 +303,7 @@ export interface TemplateSpanModel {
     readonly text: string;
 }
 /** Compiler-independent TypeScript type expression. */
-export type TypeNodeModel = {
+export type TypeNodeModel = ({
     readonly id: TypeNodeId;
     readonly kind: 'keyword';
     readonly name: KeywordTypeName;
@@ -403,6 +404,9 @@ export type TypeNodeModel = {
 } | {
     readonly id: TypeNodeId;
     readonly kind: 'this';
+}) & {
+    /** Canonical lossless JsonValue, represented without recursive tool-schema references. */
+    readonly json?: true;
 };
 /**
  * Return the direct type-expression edges owned by one node.

package/lib/types/tool-schema.d.ts

@@ -0,0 +1,20 @@
+/** Lossless projection into the harness tool-schema subset. */
+import type { TypeNodeId } from './model.ts';
+import { TypeGraphRenderer } from './renderer.ts';
+/** A resolved codec whose type the tool-schema subset cannot represent without weakening constraints. */
+export declare class ToolSchemaError extends Error {
+    name: string;
+}
+/**
+ * Project one resolved type into the tool-schema subset that `@deepseek-ai/dsh-tools`
+ * enforces on tool parameters, tool output, and the generated PTC SDK. A type the
+ * subset cannot express without weakening constraints raises {@link ToolSchemaError},
+ * which callers report as an absent projection rather than a narrower schema.
+ * @param renderer - complete analyzed type graph.
+ * @param type - resolved wire type.
+ * @param closedObjects - close declared request objects with `additionalProperties: false`.
+ * @param optional - omit a top-level undefined alternative supplied by an optional argument.
+ * @returns an acyclic schema in the tool-schema subset.
+ */
+export declare function projectToolSchema(renderer: TypeGraphRenderer, type: TypeNodeId, closedObjects?: boolean, optional?: boolean): Record<string, unknown>;
+//# sourceMappingURL=tool-schema.d.ts.map

package/lib/types/tool-schema.js

@@ -0,0 +1,156 @@
+/** Lossless projection into the harness tool-schema subset. */
+/** A resolved codec whose type the tool-schema subset cannot represent without weakening constraints. */
+export class ToolSchemaError extends Error {
+    name = 'ToolSchemaError';
+}
+/**
+ * Project one resolved type into the tool-schema subset that `@deepseek-ai/dsh-tools`
+ * enforces on tool parameters, tool output, and the generated PTC SDK. A type the
+ * subset cannot express without weakening constraints raises {@link ToolSchemaError},
+ * which callers report as an absent projection rather than a narrower schema.
+ * @param renderer - complete analyzed type graph.
+ * @param type - resolved wire type.
+ * @param closedObjects - close declared request objects with `additionalProperties: false`.
+ * @param optional - omit a top-level undefined alternative supplied by an optional argument.
+ * @returns an acyclic schema in the tool-schema subset.
+ */
+export function projectToolSchema(renderer, type, closedObjects = false, optional = false) {
+    const active = new Set();
+    const fail = (subject) => { throw new ToolSchemaError(`typert tool schema: ${subject}`); };
+    const project = (id, optional = false) => {
+        const node = renderer.node(id);
+        if (node.json)
+            return {};
+        if (active.has(id))
+            return fail('recursive selected type requires a supported JSON value declaration');
+        active.add(id);
+        try {
+            switch (node.kind) {
+                case 'keyword': {
+                    if (['string', 'number', 'boolean'].includes(node.name))
+                        return { type: node.name };
+                    return fail(`unsupported ${node.name} value`);
+                }
+                case 'literal': {
+                    if (typeof node.value === 'bigint')
+                        return fail('bigint is not JSON');
+                    return { type: node.value === null ? 'null' : typeof node.value, const: node.value };
+                }
+                case 'parenthesized': return project(node.type, optional);
+                case 'array': return { type: 'array', items: project(node.element) };
+                case 'object': return object(node.members);
+                case 'reference': {
+                    if (node.target.kind !== 'declaration' || node.arguments.length !== 0) {
+                        return fail(`unsupported selected reference ${node.name}`);
+                    }
+                    const declaration = renderer.declaration(node.target.symbol);
+                    const schema = declaration.kind === 'alias' && declaration.type !== undefined
+                        ? project(declaration.type, optional)
+                        : object(declaration.members);
+                    if (declaration.extends.length > 0)
+                        return fail('unresolved inherited selected type');
+                    return declaration.description === undefined ? schema : { ...schema, description: declaration.description };
+                }
+                case 'union': {
+                    const branches = node.types.filter((item) => {
+                        const branch = renderer.node(item);
+                        return !(optional && branch.kind === 'keyword' && branch.name === 'undefined');
+                    }).map(item => project(item));
+                    return union(branches);
+                }
+                default: return fail(`unsupported selected ${node.kind} type`);
+            }
+        }
+        finally {
+            active.delete(id);
+        }
+    };
+    const object = (members) => {
+        const properties = {};
+        const required = [];
+        let indexed = false;
+        for (const member of members) {
+            if (member.static || member.visibility !== 'public' || member.computed === 'symbol')
+                continue;
+            if (member.kind === 'index') {
+                const key = member.signature.parameters[0];
+                if (key === undefined || project(key.type).type !== 'string'
+                    || Object.keys(project(member.signature.returns)).length !== 0) {
+                    return fail('selected dictionaries require string keys and unconstrained JSON values');
+                }
+                indexed = true;
+                continue;
+            }
+            if (member.kind !== 'property' || member.computed === 'dynamic')
+                return fail(`unsupported member ${member.name}`);
+            const name = member.jsonName ?? member.name;
+            const schema = project(member.type, member.optional);
+            properties[name] = member.description === undefined ? schema : { ...schema, description: member.description };
+            if (!member.optional)
+                required.push(name);
+        }
+        return { type: 'object', properties, required, additionalProperties: indexed || !closedObjects };
+    };
+    const union = (input) => {
+        if (input.some(branch => Object.keys(branch).length === 0))
+            return {};
+        const branches = [];
+        for (const branch of input) {
+            const scalar = branch.type !== undefined && !['object', 'array'].includes(branch.type);
+            const previous = scalar ? branches.find(candidate => candidate.type === branch.type) : undefined;
+            if (previous === undefined) {
+                branches.push(branch);
+                continue;
+            }
+            const values = literals(previous);
+            const next = literals(branch);
+            if (values === undefined || next === undefined) {
+                delete previous.const;
+                delete previous.enum;
+            }
+            else {
+                delete previous.const;
+                previous.enum = [...new Set([...values, ...next])];
+            }
+        }
+        if (branches.length === 1)
+            return branches[0];
+        if (branches.length === 0)
+            return fail('empty selected union');
+        for (const [index, left] of branches.entries()) {
+            for (const right of branches.slice(index + 1)) {
+                if (!disjoint(left, right))
+                    return fail('selected union branches overlap or have no required discriminator');
+            }
+        }
+        return { oneOf: branches };
+    };
+    return project(type, optional);
+}
+function literals(schema) {
+    if (schema.const !== undefined)
+        return [schema.const];
+    return schema.enum;
+}
+function disjoint(left, right) {
+    if (left.oneOf !== undefined)
+        return left.oneOf.every(branch => disjoint(branch, right));
+    if (right.oneOf !== undefined)
+        return right.oneOf.every(branch => disjoint(left, branch));
+    if (left.type !== right.type)
+        return left.type !== undefined && right.type !== undefined;
+    if (left.type !== 'object' || right.type !== 'object')
+        return false;
+    return (left.required ?? []).some((name) => {
+        if (!right.required?.includes(name))
+            return false;
+        const a = left.properties?.[name];
+        const b = right.properties?.[name];
+        if (a === undefined || b === undefined)
+            return false;
+        const first = literals(a);
+        const second = literals(b);
+        return first !== undefined && second !== undefined && first.every(value => !second.includes(value));
+    });
+}
+//# sourceMappingURL=tool-schema.js.map

package/lib/types/tsdown-plugin.d.ts

@@ -2,20 +2,31 @@
  * Optional tsdown (rolldown) plugin face of the typert generator. It lowers
  * standard decorators in TypeScript dependencies before bundling, then emits
  * model-driven face artifacts at the package output root. Packages without a
- * Typert or Remote export are skipped.
+ * Typert or Remote export are skipped. Workspace mode generates in a Worker
+ * Thread started by the pass's first `buildStart`, so bundling continues on the
+ * main thread while Typert analyzes; the pass's first `writeBundle` awaits the
+ * result and writes every artifact once.
  * @module @deepseek-ai/dsh-typert-generator/tsdown
  */
 import type { TypertFace } from './model.ts';
 /** The subset of the rolldown plugin contract used here (structural; avoids a rolldown type dependency). */
 interface TypertPlugin {
     name: string;
-    transform: (code: string, id: string) => {
-        code: string;
-        map: string | undefined;
-    } | undefined;
+    buildStart: (options: {
+        cwd: string;
+    }) => void;
+    transform: {
+        filter: {
+            id: RegExp;
+        };
+        handler: (code: string, id: string) => {
+            code: string;
+            map: string | undefined;
+        } | undefined;
+    };
     writeBundle: (options: {
         dir?: string;
-    }) => void;
+    }) => Promise<void>;
 }
 /** Generation scope selected by a tsdown build phase. */
 export interface TypertPluginOptions {
@@ -24,6 +35,10 @@ export interface TypertPluginOptions {
     /** Independent TypeScript program faces included in this phase. */
     readonly faces?: readonly TypertFace[];
 }
+/** A workspace-mode generation failure reported by, or observed on, the Typert Worker Thread. */
+export declare class TypertWorkerError extends Error {
+    name: string;
+}
 /**
  * Create the decorator-lowering and typert-generation plugin for the root tsdown config.
  * @param pluginOptions - package/workspace emission mode and independent program faces.

package/lib/types/tsdown-plugin.js

@@ -2,18 +2,29 @@
  * Optional tsdown (rolldown) plugin face of the typert generator. It lowers
  * standard decorators in TypeScript dependencies before bundling, then emits
  * model-driven face artifacts at the package output root. Packages without a
- * Typert or Remote export are skipped.
+ * Typert or Remote export are skipped. Workspace mode generates in a Worker
+ * Thread started by the pass's first `buildStart`, so bundling continues on the
+ * main thread while Typert analyzes; the pass's first `writeBundle` awaits the
+ * result and writes every artifact once.
  * @module @deepseek-ai/dsh-typert-generator/tsdown
  */
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
+import { Worker } from 'node:worker_threads';
 import ts from 'typescript';
-import { WorkspaceTypertGenerator } from "./workspace.js";
+import { writePackageArtifacts, writeWorkspaceArtifacts } from "./artifact-files.js";
+import { findWorkspaceRoot, hasTypertExport, WorkspaceTypertGenerator } from "./workspace.js";
+/** A module id whose path (before any `?query`) names a TypeScript source. */
+const TYPESCRIPT_MODULE = /^[^?]*\.[cm]?tsx?(?:\?|$)/;
 const DECORATOR_SYNTAX = /^\s*@[A-Za-z_$][\w$]*/m;
 // Full builds and typecheck own TypeScript diagnostics. Benchmark-only emission
 // defers them to the required full-build CI jobs; Typert generates reflection
 // without repeating those diagnostics.
 const TSC_OWNED_DIAGNOSTICS = { checkDiagnostics: false };
+/** A workspace-mode generation failure reported by, or observed on, the Typert Worker Thread. */
+export class TypertWorkerError extends Error {
+    name = 'TypertWorkerError';
+}
 /**
  * Create the decorator-lowering and typert-generation plugin for the root tsdown config.
  * @param pluginOptions - package/workspace emission mode and independent program faces.
@@ -21,39 +32,68 @@ const TSC_OWNED_DIAGNOSTICS = { checkDiagnostics: false };
  */
 export function typertPlugin(pluginOptions = {}) {
     const artifactsByRoot = new Map();
+    const generations = new Map();
     const emittedWorkspaces = new Set();
+    const workspaceGeneration = (root) => {
+        let generation = generations.get(root);
+        if (generation === undefined) {
+            generation = generateInWorker({
+                root,
+                ...(pluginOptions.faces === undefined ? {} : { faces: pluginOptions.faces }),
+                options: TSC_OWNED_DIAGNOSTICS,
+            });
+            generations.set(root, generation);
+        }
+        return generation;
+    };
     return {
         name: 'dsh-typert-generator',
-        transform(code, id) {
-            const file = id.split('?', 1)[0] ?? id;
-            if (!/\.[cm]?tsx?$/.test(file) || !DECORATOR_SYNTAX.test(code))
-                return;
-            const result = ts.transpileModule(code, {
-                fileName: file,
-                compilerOptions: {
-                    target: ts.ScriptTarget.ES2024,
-                    module: ts.ModuleKind.ESNext,
-                    ...(file.endsWith('x') ? { jsx: ts.JsxEmit.ReactJSX } : {}),
-                    sourceMap: true,
-                },
-            });
-            return {
-                code: result.outputText.replace(/\n?\/\/# sourceMappingURL=.*$/u, '\n'),
-                map: result.sourceMapText,
-            };
+        buildStart(inputOptions) {
+            // tsdown builds every workspace package concurrently through this one
+            // plugin instance; the first package build to start launches generation.
+            if (pluginOptions.mode === 'workspace')
+                void workspaceGeneration(findWorkspaceRoot(inputOptions.cwd));
         },
-        writeBundle(bundleOptions) {
+        transform: {
+            // Rolldown evaluates the id filter natively, so non-TypeScript modules
+            // never cross into this JavaScript hook.
+            filter: { id: TYPESCRIPT_MODULE },
+            handler(code, id) {
+                if (!TYPESCRIPT_MODULE.test(id) || !DECORATOR_SYNTAX.test(code))
+                    return;
+                const file = id.replace(/\?.*$/su, '');
+                const result = ts.transpileModule(code, {
+                    fileName: file,
+                    compilerOptions: {
+                        target: ts.ScriptTarget.ES2024,
+                        module: ts.ModuleKind.ESNext,
+                        ...(file.endsWith('x') ? { jsx: ts.JsxEmit.ReactJSX } : {}),
+                        sourceMap: true,
+                    },
+                });
+                return {
+                    code: result.outputText.replace(/\n?\/\/# sourceMappingURL=.*$/u, '\n'),
+                    map: result.sourceMapText,
+                };
+            },
+        },
+        async writeBundle(bundleOptions) {
             // options.dir is the package's absolute outDir (<package>/lib); its
             // nearest package.json owns the bundle even when a custom config writes
             // a nested output such as <package>/lib/dev.
             if (bundleOptions.dir === undefined)
                 return;
-            const root = workspaceRoot(bundleOptions.dir);
+            const root = findWorkspaceRoot(bundleOptions.dir);
             if (emittedWorkspaces.has(root))
                 return;
             if (pluginOptions.mode === 'workspace') {
-                emitWorkspace(root, pluginOptions.faces);
+                // The first bundle to finish claims emission and reports any failure;
+                // later bundles of the pass return without waiting.
                 emittedWorkspaces.add(root);
+                const outcome = await workspaceGeneration(root);
+                if (!outcome.ok)
+                    throw outcome.error;
+                writeWorkspaceArtifacts(root, outcome.artifacts);
                 return;
             }
             const packageDir = packageRoot(bundleOptions.dir, root);
@@ -70,53 +110,122 @@ export function typertPlugin(pluginOptions = {}) {
                     : generator.generate(undefined, pluginOptions.faces);
                 artifactsByRoot.set(root, artifacts);
             }
-            emitArtifacts(packageDir, artifacts.filter(candidate => candidate.package === manifest.name));
+            writePackageArtifacts(packageDir, artifacts.filter(candidate => candidate.package === manifest.name));
         },
     };
-    function emitWorkspace(root, faces) {
-        const generator = new WorkspaceTypertGenerator(root, TSC_OWNED_DIAGNOSTICS);
-        const packages = generator.discover(faces)
-            .filter(candidate => hasTypertExport(readManifest(join(root, candidate.root)).exports))
-            .map(candidate => candidate.package);
-        if (packages.length === 0)
-            return;
-        for (const artifact of generator.generate(packages, faces)) {
-            emitArtifacts(join(root, artifact.packageRoot), [artifact]);
-        }
+}
+/**
+ * Run workspace generation in a Worker Thread. The outcome never rejects, and
+ * every terminal path terminates the worker before the outcome settles.
+ */
+function generateInWorker(request) {
+    const worker = spawnWorker(request);
+    return new Promise((settle) => {
+        let settled = false;
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            worker.terminate().then(() => { settle(outcome); }, (error) => { settle({ ok: false, error: workerError(request, 'could not terminate its worker', error) }); });
+        };
+        const fail = (problem, cause) => {
+            finish({ ok: false, error: workerError(request, problem, cause) });
+        };
+        worker.once('message', (value) => {
+            const response = parseWorkerResponse(value);
+            if (response === undefined) {
+                fail('received a malformed worker response');
+            }
+            else if (response.kind === 'failure') {
+                const cause = new Error(response.message);
+                cause.name = response.name;
+                if (response.stack !== undefined)
+                    cause.stack = response.stack;
+                fail(`failed: ${response.name}: ${response.message}`, cause);
+            }
+            else {
+                finish({ ok: true, artifacts: response.artifacts });
+            }
+        });
+        worker.once('messageerror', (error) => { fail('received a worker response that could not be deserialized', error); });
+        worker.once('error', (error) => { fail(`crashed: ${error.message}`, error); });
+        worker.once('exit', (code) => { fail(`stopped: its worker exited with code ${String(code)} before reporting artifacts`); });
+    });
+}
+function workerError(request, problem, cause) {
+    return new TypertWorkerError(`typert-generator: workspace generation for ${request.root} ${problem}`, cause === undefined ? undefined : { cause });
+}
+function spawnWorker(request) {
+    /* v8 ignore next 3 -- the tsdown host build runs the built worker entry. */
+    if (!import.meta.url.endsWith('.ts')) {
+        return new Worker(new URL('./worker.js', import.meta.url), { workerData: request });
     }
+    // Source runs load the TypeScript worker entry through tsx.
+    const bootstrap = [
+        `import { register } from ${JSON.stringify(import.meta.resolve('tsx/esm/api'))}`,
+        'register()',
+        `await import(${JSON.stringify(new URL('./worker.ts', import.meta.url).href)})`,
+    ].join('\n');
+    return new Worker(new URL(`data:text/javascript,${encodeURIComponent(bootstrap)}`), { workerData: request, execArgv: [] });
 }
-function emitArtifacts(packageDir, artifacts) {
-    const output = join(packageDir, 'lib');
-    mkdirSync(output, { recursive: true });
-    let emittedRemote = false;
-    for (const artifact of artifacts) {
-        writeFileSync(join(output, `typert.${artifact.face}.js`), artifact.js);
-        writeFileSync(join(output, `typert.${artifact.face}.d.ts`), artifact.dts);
-        if (artifact.remote !== undefined) {
-            emittedRemote = true;
-            writeFileSync(join(output, 'typert.remote-client.js'), artifact.remote.js);
-            writeFileSync(join(output, 'typert.remote-client.d.ts'), artifact.remote.dts);
-            writeFileSync(join(output, 'typert.remote-client.d.ts.map'), artifact.remote.dtsMap);
-        }
+function parseWorkerResponse(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (value.kind === 'failure') {
+        if (typeof value.name !== 'string' || typeof value.message !== 'string'
+            || (value.stack !== undefined && typeof value.stack !== 'string'))
+            return undefined;
+        return {
+            kind: 'failure',
+            name: value.name,
+            message: value.message,
+            ...(value.stack === undefined ? {} : { stack: value.stack }),
+        };
     }
-    if (!emittedRemote && artifacts.some(artifact => artifact.face === 'host')) {
-        for (const file of [
-            'typert.remote-client.js',
-            'typert.remote-client.d.ts',
-            'typert.remote-client.d.ts.map',
-        ])
-            rmSync(join(output, file), { force: true });
+    if (value.kind !== 'artifacts' || !Array.isArray(value.artifacts))
+        return undefined;
+    const artifacts = [];
+    for (const artifact of value.artifacts) {
+        const parsed = parseArtifact(artifact);
+        if (parsed === undefined)
+            return undefined;
+        artifacts.push(parsed);
     }
+    return { kind: 'artifacts', artifacts };
 }
-function readManifest(packageDir) {
-    return JSON.parse(readFileSync(join(packageDir, 'package.json'), 'utf8'));
+function parseArtifact(value) {
+    if (!isRecord(value)
+        || typeof value.package !== 'string'
+        || typeof value.packageRoot !== 'string'
+        || (value.face !== 'host' && value.face !== 'client')
+        || !Array.isArray(value.exports)
+        || !value.exports.every((entry) => typeof entry === 'string')
+        || typeof value.js !== 'string'
+        || typeof value.dts !== 'string')
+        return undefined;
+    const remote = parseRemoteArtifact(value.remote);
+    if (value.remote !== undefined && remote === undefined)
+        return undefined;
+    return {
+        package: value.package,
+        packageRoot: value.packageRoot,
+        face: value.face,
+        exports: value.exports,
+        js: value.js,
+        dts: value.dts,
+        ...(remote === undefined ? {} : { remote }),
+    };
+}
+function parseRemoteArtifact(value) {
+    if (!isRecord(value)
+        || typeof value.js !== 'string'
+        || typeof value.dts !== 'string'
+        || typeof value.dtsMap !== 'string')
+        return undefined;
+    return { js: value.js, dts: value.dts, dtsMap: value.dtsMap };
 }
-function hasTypertExport(exportsField) {
-    if (exportsField === null || typeof exportsField !== 'object' || Array.isArray(exportsField))
-        return false;
-    return Object.hasOwn(exportsField, './typert')
-        || Object.hasOwn(exportsField, './client/typert')
-        || Object.hasOwn(exportsField, './remote');
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 function packageRoot(start, workspace) {
     let current = resolve(start);
@@ -127,14 +236,4 @@ function packageRoot(start, workspace) {
     }
     return undefined;
 }
-function workspaceRoot(start) {
-    let current = resolve(start);
-    while (!existsSync(join(current, 'tsconfig.host.json'))) {
-        const parent = dirname(current);
-        if (parent === current)
-            throw new Error(`typert-generator: cannot find workspace root above ${start}`);
-        current = parent;
-    }
-    return current;
-}
 //# sourceMappingURL=tsdown-plugin.js.map

package/lib/types/worker.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Worker Thread entry for workspace-mode Typert generation. It generates every
+ * explicit contributor of the requested workspace, posts exactly one
+ * {@link WorkspaceWorkerResponse}, and exits.
+ * @module @deepseek-ai/dsh-typert-generator/worker
+ */
+import type { WorkspaceEmitResult, WorkspaceTypertGeneratorOptions } from './workspace.ts';
+import type { TypertFace } from './model.ts';
+/** Generation inputs passed as `workerData`. */
+export interface WorkspaceWorkerRequest {
+    /** Workspace root containing the face aggregate tsconfigs. */
+    readonly root: string;
+    /** Faces to generate; every face when absent. */
+    readonly faces?: readonly TypertFace[];
+    /** Generator switches applied to the pass. */
+    readonly options: WorkspaceTypertGeneratorOptions;
+}
+/** The single message the worker posts: every generated artifact, or the failure that stopped generation. */
+export type WorkspaceWorkerResponse = {
+    readonly kind: 'artifacts';
+    readonly artifacts: readonly WorkspaceEmitResult[];
+} | {
+    readonly kind: 'failure';
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+};
+//# sourceMappingURL=worker.d.ts.map

package/lib/types/worker.js

@@ -0,0 +1,49 @@
+/**
+ * Worker Thread entry for workspace-mode Typert generation. It generates every
+ * explicit contributor of the requested workspace, posts exactly one
+ * {@link WorkspaceWorkerResponse}, and exits.
+ * @module @deepseek-ai/dsh-typert-generator/worker
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+import { WorkspaceTypertGenerator } from "./workspace.js";
+function parseRequest(value) {
+    const request = typeof value === 'object' && value !== null
+        ? value
+        : {};
+    const { root, faces, options } = request;
+    const checkDiagnostics = typeof options === 'object' && options !== null
+        ? options.checkDiagnostics
+        : null;
+    if (typeof root !== 'string'
+        || (faces !== undefined
+            && (!Array.isArray(faces) || !faces.every((face) => face === 'host' || face === 'client')))
+        || (checkDiagnostics !== undefined && typeof checkDiagnostics !== 'boolean')) {
+        throw new TypeError('typert-generator: malformed workspace worker request');
+    }
+    return {
+        root,
+        ...(faces === undefined ? {} : { faces }),
+        options: checkDiagnostics === undefined ? {} : { checkDiagnostics },
+    };
+}
+function respond() {
+    try {
+        const request = parseRequest(workerData);
+        const generator = new WorkspaceTypertGenerator(request.root, request.options);
+        return { kind: 'artifacts', artifacts: generator.generateContributors(request.faces) };
+    }
+    catch (error) {
+        if (!(error instanceof Error))
+            return { kind: 'failure', name: 'Error', message: String(error) };
+        return {
+            kind: 'failure',
+            name: error.name,
+            message: error.message,
+            ...(error.stack === undefined ? {} : { stack: error.stack }),
+        };
+    }
+}
+if (parentPort === null)
+    throw new Error('typert-generator: the workspace worker entry must run in a Worker Thread');
+parentPort.postMessage(respond());
+//# sourceMappingURL=worker.js.map