@lostgradient/weft 0.17.0 → 0.19.0

package/dist/worker/manifest/internal-realm.js

@@ -0,0 +1,39 @@
+import { DEFAULT_WORKFLOW_VERSION } from "../../core/versioning.js";
+import { WORKER_PROTOCOL_VERSION } from "../../core/worker-protocol.js";
+import { VERSION } from "../../version.js";
+import { declaredShapeDigest } from "./declared-shape-digest.js";
+import {
+  WORKER_MANIFEST_VERSION
+} from "./index.js";
+export const INTERNAL_WORKER_REALM_DEPLOYMENT_NAME = "internal-worker-realm", INTERNAL_WORKER_REALM_RUNTIME_NAME = "internal-worker-realm";
+export function buildDeclaredWorkflowContract(workflowType) {
+  const digest = declaredShapeDigest(workflowType);
+  return {
+    workflowVersion: DEFAULT_WORKFLOW_VERSION,
+    workflowRevision: digest,
+    contractHash: digest,
+    activities: {}
+  };
+}
+export function declaredWorkflowContractsMatch(reported, expected) {
+  return reported.workflowVersion === expected.workflowVersion && reported.workflowRevision === expected.workflowRevision && reported.contractHash === expected.contractHash && Object.keys(reported.activities).length === 0 && Object.keys(expected.activities).length === 0;
+}
+export function buildInternalRealmManifest(workflowTypes) {
+  const sortedTypes = [...workflowTypes].toSorted(), workflows = {};
+  for (const workflowType of sortedTypes)
+    workflows[workflowType] = buildDeclaredWorkflowContract(workflowType);
+  const artifactDigest = declaredShapeDigest(sortedTypes.join(","));
+  return {
+    manifestVersion: WORKER_MANIFEST_VERSION,
+    protocolVersion: WORKER_PROTOCOL_VERSION,
+    sdkVersion: VERSION,
+    runtime: { name: INTERNAL_WORKER_REALM_RUNTIME_NAME, version: VERSION },
+    deployment: {
+      name: INTERNAL_WORKER_REALM_DEPLOYMENT_NAME,
+      buildId: artifactDigest,
+      artifactDigest
+    },
+    workflows,
+    capabilities: {}
+  };
+}

package/dist/worker/manifest/is-record.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared plain-object predicate for untrusted manifest input.
+ *
+ * `typeof value === 'object'` alone accepts `Date`, `Map`, `RegExp`, and other
+ * exotic-prototype instances — `Object.keys()` on those returns an empty
+ * array, so a hostile or malformed manifest field silently parses as an
+ * empty collection instead of being rejected. Only a plain object literal or
+ * a null-prototype object is a JSON object.
+ *
+ * @module worker/manifest/is-record
+ */
+export declare function isRecord(value: unknown): value is Readonly<Record<string, unknown>>;

package/dist/worker/manifest/is-record.js

@@ -0,0 +1,6 @@
+export function isRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return !1;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+}

package/dist/worker/manifest/json-scan.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Duplicate-key detection for JSON text.
+ *
+ * `JSON.parse` resolves `{"a":1,"a":2}` to `{a: 2}` silently. For a manifest
+ * that is unacceptable: two peers reading the same bytes could disagree about
+ * which artifact digest a worker claimed, and a digest computed after parsing
+ * would attest to only one of them. Duplicate keys are therefore rejected
+ * while the text is still text.
+ *
+ * The scanner is a structural pass, not a full parser — it locates strings and
+ * object boundaries well enough to collect key names per object, and leaves
+ * every other validity question to `JSON.parse`, which runs afterwards.
+ *
+ * @module worker/manifest/json-scan
+ */
+/**
+ * Report the first duplicate key in JSON text, or `undefined` when every
+ * object has unique keys.
+ *
+ * Malformed text yields `undefined` rather than a diagnosis: this pass only
+ * answers the duplicate-key question, and `JSON.parse` gives a better message
+ * for everything else. Text nested deeper than
+ * {@link MAX_JSON_SCAN_NESTING_DEPTH} is treated the same way — the scan
+ * bails before the open-container stack can grow without bound.
+ */
+export declare function findDuplicateJsonKey(text: string): string | undefined;

package/dist/worker/manifest/json-scan.js

@@ -0,0 +1,88 @@
+import { MAX_JSON_SCAN_NESTING_DEPTH } from "./limits.js";
+function readString(text, start) {
+  let value = "", index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      const escaped = text[index + 1];
+      if (escaped === void 0)
+        return;
+      if (escaped === "u") {
+        const hex = text.slice(index + 2, index + 6);
+        if (!/^[0-9a-fA-F]{4}$/.test(hex))
+          return;
+        const code = Number.parseInt(hex, 16);
+        value += String.fromCharCode(code);
+        index += 6;
+        continue;
+      }
+      const decoded = {
+        '"': '"',
+        "\\": "\\",
+        "/": "/",
+        b: "\b",
+        f: "\f",
+        n: `
+`,
+        r: "\r",
+        t: "\t"
+      }[escaped];
+      if (decoded === void 0)
+        return;
+      value += decoded;
+      index += 2;
+      continue;
+    }
+    if (char === '"')
+      return { value, next: index + 1 };
+    value += char;
+    index += 1;
+  }
+  return;
+}
+export function findDuplicateJsonKey(text) {
+  const stack = [];
+  let expectKey = !1, index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === '"') {
+      const parsed = readString(text, index);
+      if (parsed === void 0)
+        return;
+      if (expectKey) {
+        const keys = stack[stack.length - 1];
+        if (keys !== void 0) {
+          if (keys.has(parsed.value))
+            return parsed.value;
+          keys.add(parsed.value);
+        }
+        expectKey = !1;
+      }
+      index = parsed.next;
+      continue;
+    }
+    if ((char === "{" || char === "[") && stack.length >= MAX_JSON_SCAN_NESTING_DEPTH)
+      return;
+    expectKey = applyStructuralCharacter(char, stack, expectKey);
+    index += 1;
+  }
+  return;
+}
+function applyStructuralCharacter(char, stack, expectKey) {
+  switch (char) {
+    case "{":
+      stack.push(new Set);
+      return !0;
+    case "[":
+      stack.push(void 0);
+      return !1;
+    case "}":
+    case "]":
+      stack.pop();
+      return !1;
+    case ",":
+      return stack[stack.length - 1] !== void 0;
+    default:
+      return expectKey;
+  }
+}

package/dist/worker/manifest/limits.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Semantic bounds applied to a worker manifest before it is normalized,
+ * digested, or admitted to a registry.
+ *
+ * Lives in a leaf module so the type declarations, the hostile-input parser,
+ * and the canonical serializer can all depend on the limits without forming an
+ * import cycle — the same placement rationale as `worker/protocol-version`.
+ *
+ * These limits are deliberately separate from the transport's raw frame
+ * ceiling. A WebSocket frame guard bounds allocation; these bound the
+ * *semantic* shape a worker may assert, which is what keeps registry
+ * insertion, diagnostics, and key construction predictable.
+ *
+ * @module worker/manifest/limits
+ */
+/**
+ * Maximum UTF-8 byte length of any single identifier-shaped manifest string —
+ * deployment name, build ID, artifact digest, runtime name/version, SDK
+ * version, workflow/activity key, workflow revision, or contract hash.
+ *
+ * Measured in bytes rather than code units so an astral-plane string cannot
+ * carry four times the intended payload.
+ *
+ * @example
+ * ```ts
+ * import { MAX_MANIFEST_IDENTIFIER_BYTES } from '@lostgradient/weft';
+ *
+ * const buildId = 'release-2026.08.18';
+ * const fits = new TextEncoder().encode(buildId).byteLength <= MAX_MANIFEST_IDENTIFIER_BYTES;
+ * console.log(fits); // true
+ * ```
+ */
+export declare const MAX_MANIFEST_IDENTIFIER_BYTES = 512;
+/**
+ * Maximum number of workflow entries one manifest may advertise.
+ *
+ * @example
+ * ```ts
+ * import { MAX_MANIFEST_WORKFLOW_COUNT } from '@lostgradient/weft';
+ *
+ * const advertised = ['checkout', 'refund'];
+ * console.log(advertised.length <= MAX_MANIFEST_WORKFLOW_COUNT); // true
+ * ```
+ */
+export declare const MAX_MANIFEST_WORKFLOW_COUNT = 512;
+/**
+ * Maximum number of activity entries within one workflow entry.
+ *
+ * @example
+ * ```ts
+ * import { MAX_MANIFEST_ACTIVITY_COUNT } from '@lostgradient/weft';
+ *
+ * console.log(MAX_MANIFEST_ACTIVITY_COUNT >= 1); // true
+ * ```
+ */
+export declare const MAX_MANIFEST_ACTIVITY_COUNT = 512;
+/**
+ * Maximum number of keys in the manifest `capabilities` record.
+ *
+ * @example
+ * ```ts
+ * import { MAX_MANIFEST_CAPABILITY_COUNT } from '@lostgradient/weft';
+ *
+ * const capabilities = { gpu: true, region: 'us-east-1' };
+ * console.log(Object.keys(capabilities).length <= MAX_MANIFEST_CAPABILITY_COUNT); // true
+ * ```
+ */
+export declare const MAX_MANIFEST_CAPABILITY_COUNT = 64;
+/**
+ * Maximum nesting depth permitted inside a single `capabilities` value.
+ *
+ * Depth 1 is a scalar. `isJSONValue()` is cycle-safe but unbounded, so the
+ * manifest parser imposes this itself rather than delegating.
+ *
+ * @example
+ * ```ts
+ * import { MAX_MANIFEST_CAPABILITY_DEPTH } from '@lostgradient/weft';
+ *
+ * // { limits: { cpu: 4 } } is depth 3: object, object, scalar.
+ * console.log(3 <= MAX_MANIFEST_CAPABILITY_DEPTH); // true
+ * ```
+ */
+export declare const MAX_MANIFEST_CAPABILITY_DEPTH = 8;
+/**
+ * Maximum UTF-8 byte length of any single string inside `capabilities`.
+ *
+ * @example
+ * ```ts
+ * import { MAX_MANIFEST_CAPABILITY_STRING_BYTES } from '@lostgradient/weft';
+ *
+ * const note = 'gpu pool: a100';
+ * console.log(note.length <= MAX_MANIFEST_CAPABILITY_STRING_BYTES); // true
+ * ```
+ */
+export declare const MAX_MANIFEST_CAPABILITY_STRING_BYTES = 4096;
+/**
+ * Maximum UTF-8 byte length of the canonical normalized manifest.
+ *
+ * Checked against the canonical serialization — not the received bytes — so a
+ * worker cannot evade the bound with whitespace-minimized input and then
+ * expand under normalization.
+ *
+ * @example
+ * ```ts
+ * import { canonicalWorkerManifestJson, MAX_NORMALIZED_MANIFEST_BYTES } from '@lostgradient/weft';
+ *
+ * const canonical = canonicalWorkerManifestJson({
+ *   manifestVersion: 1,
+ *   protocolVersion: 2,
+ *   sdkVersion: '0.18.0',
+ *   runtime: { name: 'bun', version: '1.3.14' },
+ *   deployment: { name: 'billing', buildId: 'b3', artifactDigest: 'sha256:41d0' },
+ *   workflows: {},
+ *   capabilities: {},
+ * });
+ *
+ * console.log(canonical.length <= MAX_NORMALIZED_MANIFEST_BYTES); // true
+ * ```
+ */
+export declare const MAX_NORMALIZED_MANIFEST_BYTES = 262144;
+/**
+ * Maximum structural nesting depth the pre-parse duplicate-key scanner will
+ * follow into raw JSON text.
+ *
+ * The scanner pushes one entry onto an open-container stack per `{`/`[`
+ * encountered, before `JSON.parse` ever runs. Without a ceiling here, a run
+ * of open-brace characters well under the transport frame limit forces
+ * millions of allocations. No legitimate manifest — workflows, activities,
+ * and an 8-deep `capabilities` value — nests anywhere close to this bound.
+ *
+ * @example
+ * ```ts
+ * import { MAX_JSON_SCAN_NESTING_DEPTH } from '@lostgradient/weft';
+ *
+ * console.log(MAX_JSON_SCAN_NESTING_DEPTH >= 16); // true
+ * ```
+ */
+export declare const MAX_JSON_SCAN_NESTING_DEPTH = 64;

package/dist/worker/manifest/limits.js

@@ -0,0 +1 @@
+export const MAX_MANIFEST_IDENTIFIER_BYTES = 512, MAX_MANIFEST_WORKFLOW_COUNT = 512, MAX_MANIFEST_ACTIVITY_COUNT = 512, MAX_MANIFEST_CAPABILITY_COUNT = 64, MAX_MANIFEST_CAPABILITY_DEPTH = 8, MAX_MANIFEST_CAPABILITY_STRING_BYTES = 4096, MAX_NORMALIZED_MANIFEST_BYTES = 262144, MAX_JSON_SCAN_NESTING_DEPTH = 64;

package/dist/worker/manifest/normalize.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Deterministic normalization and canonical serialization for worker
+ * manifests.
+ *
+ * Two manifests that describe the same worker must produce byte-identical
+ * canonical output regardless of how their object keys were ordered in the
+ * source, so the digest identifies the *content* rather than an accident of
+ * construction. Serialization walks the declared manifest shape explicitly
+ * instead of generically stringifying the input, which means an unknown extra
+ * property can never leak into the canonical bytes and change a digest.
+ *
+ * @module worker/manifest/normalize
+ */
+import type { WorkerManifest } from './types.ts';
+/**
+ * Normalize a manifest into its canonical in-memory form.
+ *
+ * Field order follows the declared shape and every open-ended record is
+ * rebuilt with its keys sorted. The result is a fresh value; the input is not
+ * mutated.
+ *
+ * @example
+ * ```ts
+ * import { normalizeWorkerManifest, WORKER_MANIFEST_VERSION } from '@lostgradient/weft';
+ *
+ * const normalized = normalizeWorkerManifest({
+ *   manifestVersion: WORKER_MANIFEST_VERSION,
+ *   protocolVersion: 2,
+ *   sdkVersion: '0.18.0',
+ *   runtime: { name: 'bun', version: '1.3.14' },
+ *   deployment: { name: 'billing', buildId: 'b3', artifactDigest: 'sha256:41d0' },
+ *   workflows: {},
+ *   capabilities: { zeta: 1, alpha: 2 },
+ * });
+ * console.log(Object.keys(normalized.capabilities)); // ['alpha', 'zeta']
+ * ```
+ */
+export declare function normalizeWorkerManifest(manifest: WorkerManifest): WorkerManifest;
+/**
+ * Serialize a manifest to its canonical JSON string.
+ *
+ * The output is the digest input: byte-identical for equivalent manifests and
+ * different for any manifest that differs in a field the host cares about.
+ *
+ * @example
+ * ```ts
+ * import { canonicalWorkerManifestJson, WORKER_MANIFEST_VERSION } from '@lostgradient/weft';
+ *
+ * const base = {
+ *   manifestVersion: WORKER_MANIFEST_VERSION,
+ *   protocolVersion: 2,
+ *   sdkVersion: '0.18.0',
+ *   runtime: { name: 'bun', version: '1.3.14' },
+ *   deployment: { name: 'billing', buildId: 'b3', artifactDigest: 'sha256:41d0' },
+ *   workflows: {},
+ * } as const;
+ *
+ * const left = canonicalWorkerManifestJson({ ...base, capabilities: { a: 1, b: 2 } });
+ * const right = canonicalWorkerManifestJson({ ...base, capabilities: { b: 2, a: 1 } });
+ * console.log(left === right); // true
+ * ```
+ */
+export declare function canonicalWorkerManifestJson(manifest: WorkerManifest): string;

package/dist/worker/manifest/normalize.js

@@ -0,0 +1,73 @@
+import { canonicalJsonStringify } from "./canonical-json.js";
+function sortedKeys(record) {
+  return Object.keys(record).toSorted();
+}
+function sortedRecord(record, normalizeValue) {
+  const normalized = Object.create(null);
+  for (const key of sortedKeys(record))
+    normalized[key] = normalizeValue(record[key]);
+  return normalized;
+}
+function cloneJsonValue(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value))
+    return value.map((entry) => cloneJsonValue(entry));
+  const record = value, cloned = Object.create(null);
+  for (const key of Object.keys(record))
+    cloned[key] = cloneJsonValue(record[key]);
+  return cloned;
+}
+function normalizeActivity(activity) {
+  return {
+    contractHash: activity.contractHash,
+    implementationRevision: activity.implementationRevision
+  };
+}
+function normalizeWorkflow(workflow) {
+  return {
+    workflowVersion: workflow.workflowVersion,
+    workflowRevision: workflow.workflowRevision,
+    contractHash: workflow.contractHash,
+    activities: sortedRecord(workflow.activities, normalizeActivity)
+  };
+}
+export function normalizeWorkerManifest(manifest) {
+  return {
+    manifestVersion: manifest.manifestVersion,
+    protocolVersion: manifest.protocolVersion,
+    sdkVersion: manifest.sdkVersion,
+    runtime: { name: manifest.runtime.name, version: manifest.runtime.version },
+    deployment: {
+      name: manifest.deployment.name,
+      buildId: manifest.deployment.buildId,
+      artifactDigest: manifest.deployment.artifactDigest
+    },
+    workflows: sortedRecord(manifest.workflows, normalizeWorkflow),
+    capabilities: sortedRecord(manifest.capabilities, cloneJsonValue)
+  };
+}
+function canonicalActivityJson(activity) {
+  return `{"contractHash":${JSON.stringify(activity.contractHash)},"implementationRevision":${JSON.stringify(activity.implementationRevision)}}`;
+}
+function canonicalWorkflowJson(workflow) {
+  const activities = sortedKeys(workflow.activities).map((name) => `${JSON.stringify(name)}:${canonicalActivityJson(workflow.activities[name])}`).join(",");
+  return [
+    `{"workflowVersion":${JSON.stringify(workflow.workflowVersion)}`,
+    `"workflowRevision":${JSON.stringify(workflow.workflowRevision)}`,
+    `"contractHash":${JSON.stringify(workflow.contractHash)}`,
+    `"activities":{${activities}}}`
+  ].join(",");
+}
+export function canonicalWorkerManifestJson(manifest) {
+  const workflows = sortedKeys(manifest.workflows).map((name) => `${JSON.stringify(name)}:${canonicalWorkflowJson(manifest.workflows[name])}`).join(","), capabilities = sortedKeys(manifest.capabilities).map((key) => `${JSON.stringify(key)}:${canonicalJsonStringify(manifest.capabilities[key])}`).join(",");
+  return [
+    `{"manifestVersion":${JSON.stringify(manifest.manifestVersion)}`,
+    `"protocolVersion":${JSON.stringify(manifest.protocolVersion)}`,
+    `"sdkVersion":${JSON.stringify(manifest.sdkVersion)}`,
+    `"runtime":{"name":${JSON.stringify(manifest.runtime.name)},"version":${JSON.stringify(manifest.runtime.version)}}`,
+    `"deployment":{"name":${JSON.stringify(manifest.deployment.name)},"buildId":${JSON.stringify(manifest.deployment.buildId)},"artifactDigest":${JSON.stringify(manifest.deployment.artifactDigest)}}`,
+    `"workflows":{${workflows}}`,
+    `"capabilities":{${capabilities}}}`
+  ].join(",");
+}

package/dist/worker/manifest/parse-json.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Manifest validation starting from raw JSON text.
+ *
+ * Wire callers that still hold the received text should use this entry point
+ * rather than `JSON.parse` followed by {@link parseWorkerManifest}: duplicate
+ * object keys are only visible before parsing, and silently taking the last
+ * one would let a worker present two different artifact digests in one
+ * payload.
+ *
+ * @module worker/manifest/parse-json
+ */
+import { type WorkerManifestParseResult } from './parse.ts';
+/**
+ * Validate an untrusted worker manifest from JSON text.
+ *
+ * @example
+ * ```ts
+ * import { parseWorkerManifestJson } from '@lostgradient/weft';
+ *
+ * const result = parseWorkerManifestJson('{"manifestVersion":1,"manifestVersion":2}');
+ * console.log(result.ok ? 'accepted' : result.reason); // 'duplicate_key'
+ * ```
+ */
+export declare function parseWorkerManifestJson(text: string): WorkerManifestParseResult;

package/dist/worker/manifest/parse-json.js

@@ -0,0 +1,15 @@
+import { manifestFailure } from "./failure.js";
+import { findDuplicateJsonKey } from "./json-scan.js";
+import { parseWorkerManifest } from "./parse.js";
+export function parseWorkerManifestJson(text) {
+  const duplicate = findDuplicateJsonKey(text);
+  if (duplicate !== void 0)
+    return manifestFailure("duplicate_key", `manifest JSON declares the key ${JSON.stringify(duplicate)} more than once`);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return manifestFailure("invalid_json", "manifest must be valid JSON");
+  }
+  return parseWorkerManifest(parsed);
+}

package/dist/worker/manifest/parse.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Hostile-input parsing for worker manifests.
+ *
+ * Everything here treats its input as adversarial: a manifest arrives from a
+ * worker process the host does not control, and it decides whether that worker
+ * becomes routing-eligible. Every field is proven from `unknown` rather than
+ * asserted, every open-ended collection is bounded before it is walked, and
+ * the normalized size is checked against the canonical form so a compact
+ * payload cannot expand past the ceiling after normalization.
+ *
+ * @module worker/manifest/parse
+ */
+import { type ManifestValidationFailure } from './failure.ts';
+import type { WorkerManifest } from './types.ts';
+/**
+ * A successfully validated manifest, paired with the canonical serialization
+ * the digest is computed over so callers do not serialize it a second time.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   digestCanonicalWorkerManifest,
+ *   parseWorkerManifest,
+ *   type WorkerManifestParseSuccess,
+ * } from '@lostgradient/weft';
+ *
+ * const result = parseWorkerManifest({
+ *   manifestVersion: 1,
+ *   protocolVersion: 2,
+ *   sdkVersion: '0.18.0',
+ *   runtime: { name: 'bun', version: '1.3.14' },
+ *   deployment: { name: 'billing', buildId: 'b3', artifactDigest: 'sha256:41d0' },
+ *   workflows: {},
+ *   capabilities: {},
+ * });
+ *
+ * if (result.ok) {
+ *   const accepted: WorkerManifestParseSuccess = result;
+ *   console.log(await digestCanonicalWorkerManifest(accepted.canonicalJson));
+ * }
+ * ```
+ */
+export type WorkerManifestParseSuccess = Readonly<{
+    ok: true;
+    /** The normalized manifest, with every open-ended record key sorted. */
+    manifest: WorkerManifest;
+    /** Canonical serialization of that manifest — the digest input. */
+    canonicalJson: string;
+}>;
+/**
+ * Outcome of validating an untrusted manifest.
+ *
+ * @example
+ * ```ts
+ * import { parseWorkerManifest, type WorkerManifestParseResult } from '@lostgradient/weft';
+ *
+ * const result: WorkerManifestParseResult = parseWorkerManifest({});
+ * console.log(result.ok);
+ * ```
+ */
+export type WorkerManifestParseResult = WorkerManifestParseSuccess | ManifestValidationFailure;
+/**
+ * Validate an untrusted worker manifest.
+ *
+ * The returned manifest is already normalized, so a caller that stores or
+ * digests the result never has to re-derive canonical form. Rejection is a
+ * value, not an exception — a bad manifest is an ordinary wire condition.
+ *
+ * @example
+ * ```ts
+ * import { parseWorkerManifest } from '@lostgradient/weft';
+ *
+ * const result = parseWorkerManifest({
+ *   manifestVersion: 1,
+ *   protocolVersion: 2,
+ *   sdkVersion: '0.18.0',
+ *   runtime: { name: 'bun', version: '1.3.14' },
+ *   deployment: { name: 'billing', buildId: 'b3', artifactDigest: 'sha256:41d0' },
+ *   workflows: {},
+ *   capabilities: {},
+ * });
+ *
+ * console.log(result.ok ? result.manifest.deployment.name : result.reason);
+ * ```
+ */
+export declare function parseWorkerManifest(value: unknown): WorkerManifestParseResult;