tensorlake 0.5.143 → 0.5.148

package/runtime/function-executor/package/dist/function-executor/main.js

@@ -1,4902 +0,0 @@
-// src/function-executor/main.ts
-import { existsSync } from "fs";
-
-// src/native-worker-client.ts
-import { createRequire } from "module";
-import { Worker } from "worker_threads";
-
-// src/native-worker-protocol.ts
-var cancelNativeCall = /* @__PURE__ */ Symbol.for("tensorlake.native.cancel.v1");
-var closeNativeHandle = /* @__PURE__ */ Symbol.for("tensorlake.native.close.v1");
-
-// src/defaults.ts
-var SDK_VERSION = "0.5.143";
-var API_URL = process.env.TENSORLAKE_API_URL ?? "https://api.tensorlake.ai";
-var API_KEY = process.env.TENSORLAKE_API_KEY ?? void 0;
-var NAMESPACE = process.env.INDEXIFY_NAMESPACE ?? "default";
-var SANDBOX_PROXY_URL = process.env.TENSORLAKE_SANDBOX_PROXY_URL ?? "https://sandbox.tensorlake.ai";
-
-// src/url.ts
-function trimTrailingSlashes(url) {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
-}
-function resolveProxyTarget(proxyUrl, sandboxId) {
-  try {
-    const parsed = new URL(proxyUrl);
-    const host = parsed.hostname;
-    if (host === "localhost" || host === "127.0.0.1") {
-      return {
-        baseUrl: trimTrailingSlashes(proxyUrl),
-        hostHeader: `${sandboxId}.local`,
-        sandboxIdHeader: void 0
-      };
-    }
-    const port = parsed.port ? `:${parsed.port}` : "";
-    return {
-      baseUrl: `${parsed.protocol}//${host}${port}`,
-      hostHeader: void 0,
-      sandboxIdHeader: sandboxId
-    };
-  } catch {
-    return {
-      baseUrl: `${trimTrailingSlashes(proxyUrl)}/${sandboxId}`,
-      hostHeader: void 0,
-      sandboxIdHeader: void 0
-    };
-  }
-}
-
-// src/native-worker-client.ts
-var NativeWorkerClient = class {
-  constructor(workerPath = () => createRequire(import.meta.url).resolve(
-    "tensorlake/internal/native-worker"
-  )) {
-    this.workerPath = workerPath;
-  }
-  worker;
-  nextId = 1;
-  registered = /* @__PURE__ */ new Set();
-  pending = /* @__PURE__ */ new Map();
-  finalizers = new FinalizationRegistry(
-    (id) => this.release(id)
-  );
-  handle(kind, args, parent) {
-    const handle = { id: this.nextId++, kind, args, parent };
-    this.finalizers.register(handle, handle.id);
-    let closed = false;
-    return new Proxy(
-      {},
-      {
-        get: (_target, method) => {
-          if (method === "then") return void 0;
-          if (method === closeNativeHandle)
-            return () => {
-              closed = true;
-              this.release(handle.id);
-            };
-          if (method === "connectProxy")
-            return (...proxyArgs) => {
-              if (closed) throw new Error("Tensorlake native client is closed");
-              return this.handle("NativeSandboxProxyClient", proxyArgs, handle);
-            };
-          if (method === "baseUrl")
-            return () => resolveProxyTarget(String(args[0]), String(args[1])).baseUrl;
-          if (typeof method !== "string") return void 0;
-          return (...callArgs) => {
-            if (closed)
-              return Promise.reject(
-                new Error("Tensorlake native client is closed")
-              );
-            const emit = typeof callArgs.at(-1) === "function" ? callArgs.pop() : void 0;
-            return this.call(handle, method, callArgs, emit);
-          };
-        }
-      }
-    );
-  }
-  call(handle, method, args, emit) {
-    const id = this.nextId++;
-    let worker;
-    const promise = new Promise((resolve, reject) => {
-      try {
-        worker = this.getWorker();
-        this.pending.set(id, { resolve, reject, emit, handle });
-        worker.ref();
-        if (handle) this.register(handle, worker);
-        this.send(worker, {
-          type: "call",
-          id,
-          handleId: handle?.id,
-          method,
-          args,
-          stream: !!emit
-        });
-      } catch (error) {
-        this.pending.delete(id);
-        this.unrefIfIdle();
-        reject(error);
-      }
-    });
-    promise[cancelNativeCall] = () => {
-      const pending = this.pending.get(id);
-      if (pending && worker) {
-        pending.emit = void 0;
-        this.send(worker, { type: "cancel", id });
-      }
-    };
-    return promise;
-  }
-  getWorker() {
-    if (this.worker) return this.worker;
-    const worker = new Worker(this.workerPath(), {
-      // The bundled worker needs no application loaders or telemetry preloads.
-      // NODE_OPTIONS is parsed independently of execArgv by Node.
-      execArgv: [],
-      env: { ...process.env, NODE_OPTIONS: "" },
-      name: "tensorlake-native"
-    });
-    this.worker = worker;
-    worker.on("message", (message) => {
-      const pending = this.pending.get(message.id);
-      if (!pending || this.worker !== worker) return;
-      if (message.type === "event") {
-        Promise.resolve().then(() => pending.emit?.(message.value)).then(
-          () => {
-            if (this.worker === worker)
-              this.send(worker, { type: "ack", id: message.id });
-          },
-          (error) => {
-            this.send(worker, { type: "cancel", id: message.id });
-            pending.reject(error);
-          }
-        );
-        return;
-      }
-      this.pending.delete(message.id);
-      if (message.type === "error") {
-        const error = new Error(message.error.message);
-        error.name = message.error.name;
-        error.stack = message.error.stack ?? error.stack;
-        pending.reject(error);
-      } else {
-        pending.resolve(message.value);
-      }
-      this.unrefIfIdle();
-    });
-    const fail = (error) => {
-      if (this.worker !== worker) return;
-      this.worker = void 0;
-      this.registered.clear();
-      for (const pending of this.pending.values()) pending.reject(error);
-      this.pending.clear();
-      void worker.terminate();
-    };
-    worker.on("error", fail);
-    worker.on("messageerror", fail);
-    worker.on(
-      "exit",
-      (code) => fail(
-        new Error(
-          `Tensorlake native worker exited (${code}); in-flight operations were not retried`
-        )
-      )
-    );
-    worker.unref();
-    return worker;
-  }
-  register(handle, worker) {
-    if (this.registered.has(handle.id)) return;
-    if (handle.parent) this.register(handle.parent, worker);
-    this.send(worker, {
-      type: "create",
-      handle: { id: handle.id, kind: handle.kind, args: handle.args },
-      parentId: handle.parent?.id
-    });
-    this.registered.add(handle.id);
-  }
-  release(handleId) {
-    if (this.worker && this.registered.delete(handleId))
-      this.send(this.worker, { type: "release", handleId });
-  }
-  send(worker, message) {
-    worker.postMessage(message);
-  }
-  unrefIfIdle() {
-    if (this.pending.size === 0) this.worker?.unref();
-  }
-};
-var runtimeKey = /* @__PURE__ */ Symbol.for(
-  `tensorlake.native.worker.${false ? "source" : "0.5.143"}.v1`
-);
-var runtimes = globalThis;
-function configureNativeWorker(workerPath) {
-  runtimes[runtimeKey] ??= new NativeWorkerClient(workerPath);
-}
-
-// src/function-executor/main.ts
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import * as grpc2 from "@grpc/grpc-js";
-import { loadSync } from "@grpc/proto-loader";
-import { getProtoPath } from "google-proto-files";
-
-// src/function-executor/safe-output.ts
-var nativeJSONStringify = JSON.stringify;
-function captureStream(stream) {
-  stream.on("error", () => void 0);
-  return {
-    // Deployed code runs in this process and can replace stream.write. Capture
-    // the executor's writer before application modules are imported.
-    write: stream.write.bind(stream)
-  };
-}
-var executorOutput = {
-  stdout: captureStream(process.stdout),
-  stderr: captureStream(process.stderr)
-};
-function writeStructuredOutput(destination, createRecord) {
-  try {
-    const serialized = nativeJSONStringify(createRecord());
-    if (serialized == null) return;
-    executorOutput[destination].write(`${serialized}
-`, () => void 0);
-  } catch {
-  }
-}
-
-// src/function-executor/service.ts
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "fs/promises";
-import os from "os";
-import path from "path";
-import { pathToFileURL } from "url";
-import { compileFunction, constants as vmConstants } from "vm";
-import * as grpc from "@grpc/grpc-js";
-import { unzipSync } from "fflate";
-
-// src/applications/errors.ts
-var SDK_USAGE_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.sdk-usage-error.v1");
-var REQUEST_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.request-error.v1");
-var FUNCTION_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.function-error.v1");
-var TIMEOUT_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.timeout-error.v1");
-var TensorlakeApplicationError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "TensorlakeApplicationError";
-  }
-};
-var SDKUsageError = class _SDKUsageError extends TensorlakeApplicationError {
-  [SDK_USAGE_ERROR_BRAND] = true;
-  static [Symbol.hasInstance](value) {
-    if (this !== _SDKUsageError) {
-      return Function.prototype[Symbol.hasInstance].call(this, value);
-    }
-    return isSDKUsageError(value);
-  }
-  constructor(message) {
-    super(message);
-    this.name = "SDKUsageError";
-  }
-};
-function isSDKUsageError(value) {
-  if (typeof value !== "object" || value == null) return false;
-  const candidate = value;
-  return candidate[SDK_USAGE_ERROR_BRAND] === true && typeof candidate.message === "string";
-}
-var SerializationError = class extends TensorlakeApplicationError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "SerializationError";
-  }
-};
-var DeserializationError = class extends TensorlakeApplicationError {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "DeserializationError";
-  }
-};
-var FunctionError = class _FunctionError extends TensorlakeApplicationError {
-  [FUNCTION_ERROR_BRAND] = true;
-  static [Symbol.hasInstance](value) {
-    if (this !== _FunctionError) {
-      return Function.prototype[Symbol.hasInstance].call(this, value);
-    }
-    return isFunctionError(value);
-  }
-  constructor(message, options) {
-    super(message, options);
-    this.name = "FunctionError";
-  }
-};
-var TimeoutError = class _TimeoutError extends TensorlakeApplicationError {
-  [TIMEOUT_ERROR_BRAND] = true;
-  static [Symbol.hasInstance](value) {
-    if (this !== _TimeoutError) {
-      return Function.prototype[Symbol.hasInstance].call(this, value);
-    }
-    return isTimeoutError(value);
-  }
-  constructor() {
-    super("Timed out.");
-    this.name = "TimeoutError";
-  }
-};
-function isTimeoutError(value) {
-  if (typeof value !== "object" || value == null) return false;
-  const candidate = value;
-  return candidate[TIMEOUT_ERROR_BRAND] === true && typeof candidate.message === "string";
-}
-function isFunctionError(value) {
-  if (typeof value !== "object" || value == null) return false;
-  const candidate = value;
-  return candidate[FUNCTION_ERROR_BRAND] === true && typeof candidate.message === "string";
-}
-var RequestError = class _RequestError extends TensorlakeApplicationError {
-  [REQUEST_ERROR_BRAND] = true;
-  static [Symbol.hasInstance](value) {
-    if (this !== _RequestError) {
-      return Function.prototype[Symbol.hasInstance].call(this, value);
-    }
-    return isRequestError(value);
-  }
-  constructor(message, options) {
-    super(message, options);
-    this.name = "RequestError";
-  }
-};
-function isRequestError(value) {
-  if (typeof value !== "object" || value == null) return false;
-  const candidate = value;
-  return candidate[REQUEST_ERROR_BRAND] === true && typeof candidate.message === "string";
-}
-var ReplayMismatchError = class extends TensorlakeApplicationError {
-  constructor(message = "Function execution diverged from its durable event history") {
-    super(message);
-    this.name = "ReplayMismatchError";
-  }
-};
-
-// src/applications/registry.ts
-var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("tensorlake.applications.registry.v1");
-function registry() {
-  const target = globalThis;
-  target[REGISTRY_KEY] ??= { functions: /* @__PURE__ */ new Map(), applications: /* @__PURE__ */ new Map() };
-  return target[REGISTRY_KEY];
-}
-function snapshotRegistry() {
-  const state = registry();
-  return {
-    functions: new Map(state.functions),
-    applications: new Map(state.applications)
-  };
-}
-function restoreRegistry(snapshot) {
-  const state = registry();
-  state.functions.clear();
-  state.applications.clear();
-  for (const [name, definition] of snapshot.functions) state.functions.set(name, definition);
-  for (const [name, definition] of snapshot.applications) state.applications.set(name, definition);
-}
-
-// src/function-executor/allocation.ts
-import { AsyncResource, createHook, executionAsyncId as executionAsyncId2 } from "async_hooks";
-import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
-
-// src/applications/function.ts
-import { AsyncLocalStorage, executionAsyncId } from "async_hooks";
-import { randomUUID } from "crypto";
-
-// src/applications/schema.ts
-import Ajv from "ajv";
-import Ajv2020 from "ajv/dist/2020.js";
-
-// src/applications/file.ts
-var FILE_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.file.v1");
-var File = class _File {
-  [FILE_BRAND] = true;
-  content;
-  contentType;
-  static [Symbol.hasInstance](value) {
-    if (this !== _File) {
-      return Function.prototype[Symbol.hasInstance].call(this, value);
-    }
-    return isFile(value);
-  }
-  constructor(content, contentType) {
-    if (!contentType.trim()) {
-      throw new SDKUsageError("File contentType cannot be empty");
-    }
-    this.content = content instanceof Uint8Array ? content : new Uint8Array(content);
-    this.contentType = contentType;
-  }
-};
-function isFile(value) {
-  if (typeof value !== "object" || value == null) return false;
-  const candidate = value;
-  return candidate[FILE_BRAND] === true && candidate.content instanceof Uint8Array && typeof candidate.contentType === "string" && candidate.contentType.trim().length > 0;
-}
-
-// src/applications/http-body.ts
-var HTTP_BODY_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.http-body.v1");
-var HttpBody = class _HttpBody {
-  [HTTP_BODY_BRAND] = true;
-  content;
-  contentType;
-  static [Symbol.hasInstance](value) {
-    if (this !== _HttpBody) {
-      return Function.prototype[Symbol.hasInstance].call(this, value);
-    }
-    return isHttpBody(value);
-  }
-  constructor(content, contentType) {
-    this.content = content instanceof Uint8Array ? content : new Uint8Array(content);
-    this.contentType = contentType;
-  }
-  text(encoding = "utf-8") {
-    return new TextDecoder(encoding, { fatal: true }).decode(this.content);
-  }
-  json() {
-    return JSON.parse(this.text());
-  }
-};
-function isHttpBody(value) {
-  if (typeof value !== "object" || value == null) return false;
-  const candidate = value;
-  return candidate[HTTP_BODY_BRAND] === true && candidate.content instanceof Uint8Array && (candidate.contentType === void 0 || typeof candidate.contentType === "string");
-}
-
-// src/applications/schema.ts
-var ajvDraft7 = new Ajv({ allErrors: true, strict: false });
-var ajv2020 = new Ajv2020({ allErrors: true, strict: false });
-var validatorCache = /* @__PURE__ */ new WeakMap();
-function compileValidator(jsonSchema) {
-  const dialect = jsonSchema.$schema;
-  const engine = typeof dialect === "string" && /\/draft-07\/schema#?$/.test(dialect) ? ajvDraft7 : ajv2020;
-  const validate = engine.compile(jsonSchema);
-  return {
-    validate,
-    errorsText: (errors) => engine.errorsText(errors, { separator: "; " })
-  };
-}
-function validateWithSchema(valueSchema, value, label) {
-  if (valueSchema._file) {
-    if (!isFile(value)) {
-      throw new SDKUsageError(`${label} must be a Tensorlake File`);
-    }
-    return value;
-  }
-  if (valueSchema._httpBody) {
-    if (!isHttpBody(value)) {
-      throw new SDKUsageError(`${label} must be a Tensorlake HttpBody`);
-    }
-    return value;
-  }
-  if (isFile(value)) {
-    throw new SDKUsageError(`${label} must use schema.file() for a Tensorlake File`);
-  }
-  if (isHttpBody(value)) {
-    throw new SDKUsageError(
-      `${label} must use schema.httpBody() for a Tensorlake HttpBody`
-    );
-  }
-  let cached = validatorCache.get(valueSchema);
-  if (cached == null) {
-    try {
-      cached = compileValidator(valueSchema.jsonSchema);
-    } catch (error) {
-      const details = error instanceof Error ? error.message : String(error);
-      throw new SDKUsageError(`${label} uses an invalid JSON schema: ${details}`);
-    }
-    validatorCache.set(valueSchema, cached);
-  }
-  if (!cached.validate(value)) {
-    const details = cached.errorsText(cached.validate.errors);
-    throw new SDKUsageError(`${label} does not match its schema: ${details}`);
-  }
-  return value;
-}
-
-// src/applications/function.ts
-var TAIL_CALL_BRAND = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.tail-call.v1"
-);
-var DURABLE_PROMISE_OBSERVER = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.durable-promise-observer.v1"
-);
-var DURABLE_PROMISE_INTERNAL_THEN = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.durable-promise-internal-then.v1"
-);
-var FUNCTION_RUNTIME_STORAGE_KEY = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.function-runtime-storage.v1"
-);
-var PROMISE_INSTRUMENTED_KEY = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.promise-instrumented.v3"
-);
-var PROMISE_THEN_INSTRUMENTED_KEY = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.promise-then-instrumented.v1"
-);
-var DURABLE_THENABLE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.durable-thenable-registry.v2"
-);
-var INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.internal-promise-aggregate-depth.v1"
-);
-function runtimeStorage() {
-  const target = globalThis;
-  target[FUNCTION_RUNTIME_STORAGE_KEY] ??= new AsyncLocalStorage();
-  return target[FUNCTION_RUNTIME_STORAGE_KEY];
-}
-function currentFunctionRuntime() {
-  return runtimeStorage().getStore();
-}
-function runWithFunctionRuntime(runtime, callback) {
-  return runtimeStorage().run(runtime, callback);
-}
-function isDurableThenable(value) {
-  if (typeof value !== "object" && typeof value !== "function" || value == null) {
-    return false;
-  }
-  return durableThenableRegistry().has(value);
-}
-function isDetachedDurableThenable(value) {
-  const provenance = provenanceForDurableThenable(value);
-  return provenance?.detached === true || provenance?.assimilation != null && !provenance.assimilation.active;
-}
-function durableThenableRegistry() {
-  const target = globalThis;
-  target[DURABLE_THENABLE_REGISTRY_KEY] ??= /* @__PURE__ */ new WeakMap();
-  return target[DURABLE_THENABLE_REGISTRY_KEY];
-}
-function newDurableThenableMetadata() {
-  return {
-    aggregateExpectations: [],
-    provenanceExpectations: []
-  };
-}
-function metadataForDurableThenable(value) {
-  return provenanceForDurableThenable(value)?.metadata;
-}
-function provenanceForDurableThenable(value) {
-  if (typeof value !== "object" && typeof value !== "function" || value == null) {
-    return void 0;
-  }
-  return durableThenableRegistry().get(value);
-}
-function registerDurableThenable(value, source) {
-  const registry2 = durableThenableRegistry();
-  const metadata = source == null ? registry2.get(value)?.metadata ?? newDurableThenableMetadata() : registry2.get(source)?.metadata ?? newDurableThenableMetadata();
-  registry2.set(value, { metadata });
-  if (source != null && !registry2.has(source)) registry2.set(source, { metadata });
-  return value;
-}
-function registerDetachedDurableThenable(value) {
-  const registry2 = durableThenableRegistry();
-  registry2.set(value, {
-    metadata: registry2.get(value)?.metadata ?? newDurableThenableMetadata(),
-    detached: true
-  });
-  return value;
-}
-function inheritDurableThenable(value, source) {
-  const provenance = durableThenableRegistry().get(source);
-  if (provenance == null) return value;
-  durableThenableRegistry().set(value, provenance);
-  if (provenance.assimilation == null) {
-    provenance.metadata.provenanceExpectations.push({
-      value,
-      creatorAsyncId: executionAsyncId()
-    });
-  }
-  return value;
-}
-function registerDurableAssimilation(value, detach) {
-  const metadata = metadataForDurableThenable(value);
-  if (metadata == null) {
-    return {
-      finish: () => void 0,
-      link: (linked) => linked
-    };
-  }
-  const registration = {
-    active: true,
-    detach
-  };
-  const provenanceIndex = metadata.provenanceExpectations.findIndex(
-    (expectation) => expectation.creatorAsyncId !== executionAsyncId()
-  );
-  if (provenanceIndex >= 0) {
-    const [expectation] = metadata.provenanceExpectations.splice(provenanceIndex, 1);
-    durableThenableRegistry().set(expectation.value, {
-      metadata,
-      assimilation: registration
-    });
-  }
-  const expectationIndex = metadata.aggregateExpectations.findIndex(
-    (expectation) => !expectation.scope.settled && expectation.creatorAsyncId !== executionAsyncId()
-  );
-  if (expectationIndex >= 0) {
-    const [expectation] = metadata.aggregateExpectations.splice(expectationIndex, 1);
-    associateAssimilationWithAggregate(registration, expectation.scope);
-  }
-  return {
-    finish: () => finishDurableAssimilation(registration),
-    link: (linked) => {
-      durableThenableRegistry().set(linked, {
-        metadata,
-        assimilation: registration
-      });
-      return linked;
-    }
-  };
-}
-function associateAssimilationWithAggregate(registration, scope) {
-  if (!registration.active || scope.settled) return;
-  finishDurableAssimilation(registration);
-  registration.detach();
-}
-function finishDurableAssimilation(registration) {
-  if (!registration.active) return;
-  registration.active = false;
-}
-function trackDurableAggregate(runtime, result, durableContenders, markResult) {
-  const scope = {
-    settled: false,
-    metadata: /* @__PURE__ */ new Set()
-  };
-  if (markResult) {
-    registerDetachedDurableThenable(result);
-  }
-  const creatorAsyncId = executionAsyncId();
-  for (const contender of durableContenders) {
-    const provenance = provenanceForDurableThenable(contender);
-    if (provenance == null) continue;
-    if (provenance.assimilation != null) {
-      associateAssimilationWithAggregate(provenance.assimilation, scope);
-    } else {
-      provenance.metadata.aggregateExpectations.push({
-        scope,
-        creatorAsyncId
-      });
-    }
-    if (scope.metadata.has(provenance.metadata)) continue;
-    const { metadata } = provenance;
-    scope.metadata.add(metadata);
-  }
-  const settle = () => {
-    if (scope.settled) return;
-    scope.settled = true;
-    for (const metadata of scope.metadata) {
-      for (let index = metadata.aggregateExpectations.length - 1; index >= 0; index -= 1) {
-        if (metadata.aggregateExpectations[index].scope === scope) {
-          metadata.aggregateExpectations.splice(index, 1);
-        }
-      }
-    }
-    scope.metadata.clear();
-  };
-  if (runtime.trackPromiseSettlement?.(result, settle) !== true) settle();
-}
-function promiseAggregateObservation(kind) {
-  let settleLifetime;
-  const ordinaryLifetime = new Promise((resolve) => {
-    settleLifetime = resolve;
-  });
-  let contenderCount;
-  let fulfillmentCount = 0;
-  let rejectionCount = 0;
-  let settled = false;
-  const maybeSettle = () => {
-    if (settled) return;
-    const canNoLongerAdvance = kind === "any" ? contenderCount != null && rejectionCount === contenderCount : kind === "all" ? rejectionCount > 0 || contenderCount != null && fulfillmentCount === contenderCount : contenderCount != null && fulfillmentCount + rejectionCount === contenderCount;
-    if (!canNoLongerAdvance) return;
-    settled = true;
-    settleLifetime();
-  };
-  return {
-    ordinaryLifetime,
-    allOrdinaryValuesObservable: true,
-    observeFulfillment: () => {
-      fulfillmentCount += 1;
-      maybeSettle();
-    },
-    observeRejection: () => {
-      rejectionCount += 1;
-      maybeSettle();
-    },
-    finishIteration: (count) => {
-      contenderCount = count;
-      maybeSettle();
-    }
-  };
-}
-function observePromiseAggregateContender(normalized, observation) {
-  if (typeof normalized !== "object" && typeof normalized !== "function" || normalized == null) {
-    observation.allOrdinaryValuesObservable = false;
-    return normalized;
-  }
-  let observedSettled = false;
-  const observed = /* @__PURE__ */ Object.create(null);
-  Object.defineProperty(observed, "then", {
-    configurable: true,
-    get: () => {
-      const then = Reflect.get(normalized, "then", normalized);
-      if (typeof then !== "function") return then;
-      return function observedThen(onfulfilled, onrejected) {
-        return Reflect.apply(then, normalized, [
-          function observedFulfillment(value) {
-            if (!observedSettled) {
-              observedSettled = true;
-              observation.observeFulfillment();
-            }
-            return typeof onfulfilled === "function" ? Reflect.apply(onfulfilled, this, [value]) : void 0;
-          },
-          function observedRejection(reason) {
-            if (!observedSettled) {
-              observedSettled = true;
-              observation.observeRejection();
-            }
-            if (typeof onrejected === "function") {
-              return Reflect.apply(onrejected, this, [reason]);
-            }
-            throw reason;
-          }
-        ]);
-      };
-    }
-  });
-  return observed;
-}
-function observedPromiseConstructor(constructor, observeNormalized) {
-  const facade = function PromiseAggregateObservedConstructor(executor) {
-    return Reflect.construct(
-      constructor,
-      [executor],
-      constructor
-    );
-  };
-  Object.defineProperty(facade, "resolve", {
-    configurable: true,
-    get: () => {
-      const promiseResolve = Reflect.get(constructor, "resolve", constructor);
-      if (typeof promiseResolve !== "function") return promiseResolve;
-      return (value) => {
-        const normalized = Reflect.apply(promiseResolve, constructor, [value]);
-        return observeNormalized(normalized);
-      };
-    }
-  });
-  return facade;
-}
-function isInternalPromiseAggregate() {
-  const target = globalThis;
-  return (target[INTERNAL_PROMISE_AGGREGATE_DEPTH_KEY] ?? 0) > 0;
-}
-function installPromiseInstrumentation() {
-  const target = globalThis;
-  if (target[PROMISE_THEN_INSTRUMENTED_KEY] !== true) {
-    const originalThen = Promise.prototype.then;
-    Object.defineProperty(Promise.prototype, "then", {
-      ...Object.getOwnPropertyDescriptor(Promise.prototype, "then"),
-      value: function then(onfulfilled, onrejected) {
-        const result = Reflect.apply(
-          originalThen,
-          this,
-          [onfulfilled, onrejected]
-        );
-        if (isDetachedDurableThenable(this)) {
-          currentFunctionRuntime()?.trackDurablePromiseConsumption?.(result);
-        }
-        return result;
-      }
-    });
-    target[PROMISE_THEN_INSTRUMENTED_KEY] = true;
-  }
-  if (target[PROMISE_INSTRUMENTED_KEY] === true) return;
-  const originalRace = Promise.race;
-  const originalAny = Promise.any;
-  const originalAll = Promise.all;
-  const originalAllSettled = Promise.allSettled;
-  const originalResolve = Promise.resolve;
-  Object.defineProperty(Promise, "resolve", {
-    ...Object.getOwnPropertyDescriptor(Promise, "resolve"),
-    value: function resolve(value) {
-      const result = Reflect.apply(originalResolve, this, [value]);
-      if (isDurableThenable(value)) inheritDurableThenable(result, value);
-      return result;
-    }
-  });
-  Object.defineProperty(Promise, "race", {
-    ...Object.getOwnPropertyDescriptor(Promise, "race"),
-    value: function race(values) {
-      const runtime = currentFunctionRuntime();
-      if (runtime?.trackMixedPromiseRace == null) {
-        return Reflect.apply(originalRace, this, [values]);
-      }
-      const durableContenders = [];
-      let ordinaryContenderCount = 0;
-      const trackedValues = {
-        *[Symbol.iterator]() {
-          for (const value of values) {
-            yield value;
-          }
-        }
-      };
-      const observedConstructor = observedPromiseConstructor(
-        this,
-        (normalized) => {
-          if (isDurableThenable(normalized)) {
-            durableContenders.push(normalized);
-          } else {
-            ordinaryContenderCount += 1;
-          }
-          return normalized;
-        }
-      );
-      const construct = () => Reflect.apply(
-        originalRace,
-        observedConstructor,
-        [trackedValues]
-      );
-      const result = runtime.runPromiseAggregateConstruction?.(construct) ?? construct();
-      if (durableContenders.length > 0) {
-        trackDurableAggregate(
-          runtime,
-          result,
-          durableContenders,
-          !isInternalPromiseAggregate()
-        );
-      }
-      if (durableContenders.length > 0 && ordinaryContenderCount > 0) {
-        runtime.trackMixedPromiseRace(result);
-      }
-      return result;
-    }
-  });
-  Object.defineProperty(Promise, "any", {
-    ...Object.getOwnPropertyDescriptor(Promise, "any"),
-    value: function any(values) {
-      const runtime = currentFunctionRuntime();
-      if (runtime?.trackMixedPromiseRace == null) {
-        return Reflect.apply(originalAny, this, [values]);
-      }
-      const durableContenders = [];
-      let ordinaryContenderCount = 0;
-      const observation = promiseAggregateObservation("any");
-      const trackedValues = {
-        *[Symbol.iterator]() {
-          for (const value of values) {
-            yield value;
-          }
-        }
-      };
-      const observedConstructor = observedPromiseConstructor(
-        this,
-        (normalized) => {
-          if (isDurableThenable(normalized)) {
-            durableContenders.push(normalized);
-            return normalized;
-          }
-          ordinaryContenderCount += 1;
-          return observePromiseAggregateContender(normalized, observation);
-        }
-      );
-      const construct = () => Reflect.apply(
-        originalAny,
-        observedConstructor,
-        [trackedValues]
-      );
-      const result = runtime.runPromiseAggregateConstruction?.(construct) ?? construct();
-      observation.finishIteration(ordinaryContenderCount);
-      if (durableContenders.length > 0) {
-        trackDurableAggregate(
-          runtime,
-          result,
-          durableContenders,
-          !isInternalPromiseAggregate()
-        );
-      }
-      if (durableContenders.length > 0 && ordinaryContenderCount > 0) {
-        if (observation.allOrdinaryValuesObservable) {
-          runtime.trackMixedPromiseRace(result, [observation.ordinaryLifetime, result]);
-        } else {
-          runtime.trackMixedPromiseRace(result);
-        }
-      }
-      return result;
-    }
-  });
-  Object.defineProperty(Promise, "all", {
-    ...Object.getOwnPropertyDescriptor(Promise, "all"),
-    value: function all(values) {
-      const runtime = currentFunctionRuntime();
-      if (runtime?.trackMixedPromiseRace == null) {
-        return Reflect.apply(originalAll, this, [values]);
-      }
-      const durableContenders = [];
-      let ordinaryContenderCount = 0;
-      const observation = promiseAggregateObservation("all");
-      const trackedValues = {
-        *[Symbol.iterator]() {
-          for (const value of values) {
-            yield value;
-          }
-        }
-      };
-      const observedConstructor = observedPromiseConstructor(
-        this,
-        (normalized) => {
-          if (isDurableThenable(normalized)) {
-            durableContenders.push(normalized);
-            return normalized;
-          }
-          ordinaryContenderCount += 1;
-          return observePromiseAggregateContender(normalized, observation);
-        }
-      );
-      const construct = () => Reflect.apply(
-        originalAll,
-        observedConstructor,
-        [trackedValues]
-      );
-      const result = runtime.runPromiseAggregateConstruction?.(construct) ?? construct();
-      observation.finishIteration(ordinaryContenderCount);
-      if (durableContenders.length > 0) {
-        trackDurableAggregate(
-          runtime,
-          result,
-          durableContenders,
-          !isInternalPromiseAggregate()
-        );
-      }
-      if (durableContenders.length > 0 && ordinaryContenderCount > 0) {
-        if (observation.allOrdinaryValuesObservable) {
-          runtime.trackMixedPromiseRace(result, [observation.ordinaryLifetime, result]);
-        } else {
-          runtime.trackMixedPromiseRace(result);
-        }
-      }
-      return result;
-    }
-  });
-  Object.defineProperty(Promise, "allSettled", {
-    ...Object.getOwnPropertyDescriptor(Promise, "allSettled"),
-    value: function allSettled(values) {
-      const runtime = currentFunctionRuntime();
-      if (runtime?.trackMixedPromiseRace == null) {
-        return Reflect.apply(
-          originalAllSettled,
-          this,
-          [values]
-        );
-      }
-      const durableContenders = [];
-      let ordinaryContenderCount = 0;
-      const observation = promiseAggregateObservation("all_settled");
-      const trackedValues = {
-        *[Symbol.iterator]() {
-          for (const value of values) yield value;
-        }
-      };
-      const observedConstructor = observedPromiseConstructor(
-        this,
-        (normalized) => {
-          if (isDurableThenable(normalized)) {
-            durableContenders.push(normalized);
-            return normalized;
-          }
-          ordinaryContenderCount += 1;
-          return observePromiseAggregateContender(normalized, observation);
-        }
-      );
-      const construct = () => Reflect.apply(
-        originalAllSettled,
-        observedConstructor,
-        [trackedValues]
-      );
-      const result = runtime.runPromiseAggregateConstruction?.(construct) ?? construct();
-      observation.finishIteration(ordinaryContenderCount);
-      if (durableContenders.length > 0) {
-        trackDurableAggregate(
-          runtime,
-          result,
-          durableContenders,
-          !isInternalPromiseAggregate()
-        );
-      }
-      if (durableContenders.length > 0 && ordinaryContenderCount > 0) {
-        if (observation.allOrdinaryValuesObservable) {
-          runtime.trackMixedPromiseRace(result, [observation.ordinaryLifetime, result]);
-        } else {
-          runtime.trackMixedPromiseRace(result);
-        }
-      }
-      return result;
-    }
-  });
-  target[PROMISE_INSTRUMENTED_KEY] = true;
-}
-function validateArguments(definition, supplied) {
-  const args = [...supplied];
-  if (args.length > definition.parameters.length) {
-    throw new SDKUsageError(`${definition.name} expected at most ${definition.parameters.length} arguments, received ${args.length}`);
-  }
-  definition.parameters.forEach((parameter, index) => {
-    if (index >= args.length || args[index] === void 0) {
-      if (parameter.hasDefault) args[index] = parameter.defaultValue;
-      else if (parameter.required) throw new SDKUsageError(`${definition.name} is missing argument '${parameter.name}'`);
-      return;
-    }
-    validateWithSchema(parameter.schema, args[index], `${definition.name}.${parameter.name}`);
-  });
-  return args;
-}
-async function executeHandlerResult(definition, suppliedArgs) {
-  const args = validateArguments(definition, suppliedArgs);
-  const result = definition.handler(...args);
-  if (result == null || typeof result.then !== "function") {
-    throw new SDKUsageError(`Tensorlake handler '${definition.name}' must be async and return a Promise`);
-  }
-  const output = await result;
-  if (isTailCall(output)) {
-    return output;
-  }
-  validateWithSchema(definition.returns, output, `${definition.name} return value`);
-  return output;
-}
-function isTailCall(value) {
-  if (typeof value !== "object" || value == null) return false;
-  const candidate = value;
-  return candidate[TAIL_CALL_BRAND] === true && candidate.kind === "tensorlake-tail-call" && typeof candidate.definition === "object" && candidate.definition != null && Array.isArray(candidate.args);
-}
-
-// src/applications/headers.ts
-var HEADERS_BRAND = /* @__PURE__ */ Symbol.for("tensorlake.applications.headers.v1");
-var Headers2 = class _Headers {
-  [HEADERS_BRAND] = true;
-  #items;
-  #lookup;
-  static [Symbol.hasInstance](value) {
-    if (this !== _Headers) {
-      return Function.prototype[Symbol.hasInstance].call(this, value);
-    }
-    return isHeaders(value);
-  }
-  constructor(headers = []) {
-    const entries = headers instanceof _Headers ? [...headers] : Symbol.iterator in Object(headers) ? [...headers] : Object.entries(headers);
-    const lookup = /* @__PURE__ */ new Map();
-    this.#items = Object.freeze(entries.map(([name, value]) => {
-      if (typeof name !== "string" || typeof value !== "string") {
-        throw new TypeError("Headers require string names and values");
-      }
-      const item = Object.freeze([name, value]);
-      const key = name.toLowerCase();
-      lookup.set(key, [...lookup.get(key) ?? [], value]);
-      return item;
-    }));
-    this.#lookup = lookup;
-    Object.freeze(this);
-  }
-  get(name) {
-    return this.#lookup.get(name.toLowerCase())?.at(-1);
-  }
-  getAll(name) {
-    return Object.freeze([...this.#lookup.get(name.toLowerCase()) ?? []]);
-  }
-  has(name) {
-    return this.#lookup.has(name.toLowerCase());
-  }
-  entries() {
-    return this.#items[Symbol.iterator]();
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-};
-function isHeaders(value) {
-  if (typeof value !== "object" || value == null) return false;
-  const candidate = value;
-  return candidate[HEADERS_BRAND] === true && typeof candidate.get === "function" && typeof candidate.getAll === "function" && typeof candidate.has === "function" && typeof candidate[Symbol.iterator] === "function";
-}
-
-// src/applications/context.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-
-// src/applications/serialization.ts
-import { createHash } from "crypto";
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder("utf-8", { fatal: true });
-function assertJSONValue(value, path3, seen) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") return;
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) throw new SerializationError(`${path3} contains a non-finite number`);
-    return;
-  }
-  if (typeof value !== "object") {
-    throw new SerializationError(`${path3} contains unsupported ${typeof value}`);
-  }
-  if (isFile(value)) {
-    throw new SerializationError(`${path3} contains a nested File; File is only supported as a direct value`);
-  }
-  if (isHttpBody(value)) {
-    throw new SerializationError(
-      `${path3} contains a nested HttpBody; HttpBody is only supported as a direct value`
-    );
-  }
-  if (seen.has(value)) throw new SerializationError(`${path3} contains a cycle`);
-  if (Object.getPrototypeOf(value) !== Object.prototype && !Array.isArray(value)) {
-    throw new SerializationError(`${path3} contains unsupported ${value.constructor?.name ?? "object"}`);
-  }
-  seen.add(value);
-  if (Array.isArray(value)) {
-    for (let index = 0; index < value.length; index += 1) {
-      if (!Object.prototype.hasOwnProperty.call(value, index)) {
-        throw new SerializationError(`${path3} contains a sparse array entry at index ${index}`);
-      }
-      assertJSONValue(value[index], `${path3}[${index}]`, seen);
-    }
-  } else {
-    for (const [key, item] of Object.entries(value)) {
-      assertJSONValue(item, `${path3}.${key}`, seen);
-    }
-  }
-  seen.delete(value);
-}
-function serializeValue(value) {
-  if (isFile(value)) {
-    return { data: value.content, contentType: value.contentType, encoding: "raw" };
-  }
-  if (isHttpBody(value)) {
-    return {
-      data: value.content,
-      contentType: value.contentType ?? "",
-      encoding: "raw"
-    };
-  }
-  try {
-    assertJSONValue(value, "value", /* @__PURE__ */ new Set());
-    return {
-      data: textEncoder.encode(JSON.stringify(value)),
-      contentType: "application/json; charset=UTF-8",
-      encoding: "json"
-    };
-  } catch (error) {
-    if (error instanceof SerializationError) throw error;
-    throw new SerializationError("Failed to serialize JSON value", { cause: error });
-  }
-}
-function deserializeJSON(data) {
-  try {
-    return JSON.parse(textDecoder.decode(data));
-  } catch (error) {
-    throw new DeserializationError("Failed to deserialize JSON value", { cause: error });
-  }
-}
-
-// src/applications/context.ts
-function validateRequestStateKey(key) {
-  if (typeof key !== "string") {
-    throw new SDKUsageError(`State key must be a string, got: ${String(key)}`);
-  }
-}
-function serializeRequestStateValue(value) {
-  const serialized = serializeValue(value);
-  if (serialized.encoding !== "json") {
-    throw new SDKUsageError("Request state values must be JSON values");
-  }
-  return serialized.data;
-}
-function validateCounterMetric(name, value) {
-  if (typeof name !== "string") {
-    throw new SDKUsageError(`Counter name must be a string, got: ${String(name)}`);
-  }
-  if (typeof value !== "number" || !Number.isInteger(value)) {
-    throw new SDKUsageError(`Counter value must be an int, got: ${String(value)}`);
-  }
-  if (!Number.isSafeInteger(value)) {
-    throw new SDKUsageError(`Counter value must be a safe int, got: ${String(value)}`);
-  }
-}
-function validateTimerMetric(name, value) {
-  if (typeof name !== "string") {
-    throw new SDKUsageError(`Timer name must be a string, got: ${String(name)}`);
-  }
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new SDKUsageError(`Timer value must be a finite number, got: ${String(value)}`);
-  }
-}
-function isPlainRecord(value) {
-  if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function validateProgressUpdate(current, total, options) {
-  if (!Number.isFinite(current) || !Number.isFinite(total) || total < 0 || current < 0) {
-    throw new SDKUsageError("Progress current and total must be non-negative finite numbers");
-  }
-  if (options != null && !isPlainRecord(options)) {
-    throw new SDKUsageError("Progress options must be an object");
-  }
-  if (options?.message != null && typeof options.message !== "string") {
-    throw new SDKUsageError("Progress message must be a string");
-  }
-  if (options?.attributes != null) {
-    if (!isPlainRecord(options.attributes)) {
-      throw new SDKUsageError("Progress attributes must be an object of string key/value pairs");
-    }
-    for (const key of Reflect.ownKeys(options.attributes)) {
-      if (typeof key !== "string") {
-        throw new SDKUsageError("Progress attributes must contain only string keys and values");
-      }
-      const value = options.attributes[key];
-      if (typeof value !== "string") {
-        throw new SDKUsageError("Progress attributes must contain only string keys and values");
-      }
-    }
-  }
-}
-var REQUEST_CONTEXT_STORAGE_KEY = /* @__PURE__ */ Symbol.for(
-  "tensorlake.applications.request-context-storage.v1"
-);
-function requestContextStorage() {
-  const target = globalThis;
-  target[REQUEST_CONTEXT_STORAGE_KEY] ??= new AsyncLocalStorage2();
-  return target[REQUEST_CONTEXT_STORAGE_KEY];
-}
-function runWithRequestContext(context, callback) {
-  return requestContextStorage().run(context, callback);
-}
-async function waitWithAbortSignal(value, signal) {
-  if (signal.aborted) throw signal.reason;
-  let onAbort;
-  try {
-    return await Promise.race([
-      value,
-      new Promise((_resolve, reject) => {
-        onAbort = () => reject(signal.reason);
-        signal.addEventListener("abort", onAbort, { once: true });
-      })
-    ]);
-  } finally {
-    if (onAbort != null) signal.removeEventListener("abort", onAbort);
-  }
-}
-
-// src/function-executor/async-queue.ts
-function deferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((ok, fail) => {
-    resolve = ok;
-    reject = fail;
-  });
-  return { promise, resolve, reject };
-}
-
-// src/function-executor/blob.ts
-import { createHash as createHash2 } from "crypto";
-import { open } from "fs/promises";
-import { fileURLToPath } from "url";
-function enumIs(value, name, numberValue) {
-  return value === name || value === numberValue;
-}
-function concatenate(parts) {
-  const result = new Uint8Array(parts.reduce((total, part) => total + part.byteLength, 0));
-  let offset = 0;
-  for (const part of parts) {
-    result.set(part, offset);
-    offset += part.byteLength;
-  }
-  return result;
-}
-function networkURI(uri) {
-  if (uri.startsWith("s3://")) return `https://${uri.slice("s3://".length)}`;
-  if (uri.startsWith("gs://")) return `https://${uri.slice("gs://".length)}`;
-  return uri;
-}
-var BlobHTTPError = class extends Error {
-  constructor(status2) {
-    super(`BLOB operation failed with HTTP ${status2}`);
-    this.status = status2;
-  }
-};
-function uriKind(uri) {
-  if (uri.startsWith("file://")) return "file";
-  if (uri.startsWith("s3://")) return "s3";
-  if (uri.startsWith("gs://")) return "gcs";
-  try {
-    return new URL(uri).protocol.replace(":", "") || "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-function throwIfAborted(signal) {
-  signal?.throwIfAborted();
-}
-async function abortableDelay(delayMs, signal) {
-  throwIfAborted(signal);
-  if (signal == null) {
-    await new Promise((resolve) => setTimeout(resolve, delayMs));
-    return;
-  }
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, delayMs);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(signal.reason);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-async function fetchWithRetries(uri, init, log, fields = {}, signal) {
-  let lastError;
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    throwIfAborted(signal);
-    const startedAt = Date.now();
-    log?.("HTTP attempt starting", {
-      ...fields,
-      attempt: attempt + 1,
-      method: init?.method ?? "GET",
-      uri_kind: uriKind(uri),
-      has_range: new Headers(init?.headers).has("range")
-    });
-    try {
-      const response = await fetch(networkURI(uri), {
-        ...init,
-        signal
-      });
-      log?.("HTTP attempt completed", {
-        ...fields,
-        attempt: attempt + 1,
-        method: init?.method ?? "GET",
-        status_code: response.status,
-        duration_ms: Date.now() - startedAt
-      });
-      throwIfAborted(signal);
-      if (response.ok) return response;
-      if ([400, 403, 404].includes(response.status) || attempt === 3) {
-        throw new BlobHTTPError(response.status);
-      }
-      lastError = new BlobHTTPError(response.status);
-    } catch (error) {
-      log?.("HTTP attempt failed", {
-        ...fields,
-        attempt: attempt + 1,
-        method: init?.method ?? "GET",
-        duration_ms: Date.now() - startedAt,
-        error: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
-      });
-      throwIfAborted(signal);
-      if (error instanceof BlobHTTPError && [400, 403, 404].includes(error.status)) throw error;
-      lastError = error;
-      if (attempt === 3) break;
-    }
-    const retryDelayMs = 100 * 2 ** attempt;
-    log?.("HTTP attempt scheduled for retry", {
-      ...fields,
-      next_attempt: attempt + 2,
-      retry_delay_ms: retryDelayMs
-    });
-    await abortableDelay(retryDelayMs, signal);
-  }
-  throw new Error("BLOB operation failed after retries", { cause: lastError });
-}
-async function readChunkRange(chunk, index, logicalChunkOffset, offsetWithinChunk, size, sharedURI, log, signal) {
-  throwIfAborted(signal);
-  if (!chunk.uri) throw new Error("BLOB chunk has no URI");
-  const physicalOffset = sharedURI ? logicalChunkOffset + offsetWithinChunk : offsetWithinChunk;
-  const fields = {
-    chunk_index: index,
-    chunk_offset: logicalChunkOffset,
-    read_offset: physicalOffset,
-    read_bytes: size,
-    uri_kind: uriKind(chunk.uri),
-    shared_uri: sharedURI
-  };
-  const startedAt = Date.now();
-  log?.("download chunk starting", fields);
-  if (chunk.uri.startsWith("file://")) {
-    const file = await open(fileURLToPath(chunk.uri), "r");
-    try {
-      throwIfAborted(signal);
-      const data2 = new Uint8Array(size);
-      const { bytesRead } = await file.read(data2, 0, size, physicalOffset);
-      throwIfAborted(signal);
-      if (bytesRead !== size) {
-        throw new Error(`BLOB chunk ended after ${bytesRead} bytes; expected ${size}`);
-      }
-      log?.("download chunk completed", {
-        ...fields,
-        downloaded_bytes: data2.byteLength,
-        duration_ms: Date.now() - startedAt
-      });
-      return data2;
-    } finally {
-      await file.close();
-    }
-  }
-  const headers = { range: `bytes=${physicalOffset}-${physicalOffset + size - 1}` };
-  const response = await fetchWithRetries(chunk.uri, { headers }, log, fields, signal);
-  let data = new Uint8Array(await response.arrayBuffer());
-  throwIfAborted(signal);
-  if (response.status === 200 && (physicalOffset !== 0 || data.byteLength !== size)) {
-    data = data.subarray(physicalOffset, physicalOffset + size);
-  }
-  if (data.byteLength !== size) {
-    throw new Error(`BLOB chunk returned ${data.byteLength} bytes; expected ${size}`);
-  }
-  log?.("download chunk completed", {
-    ...fields,
-    status_code: response.status,
-    downloaded_bytes: data.byteLength,
-    duration_ms: Date.now() - startedAt
-  });
-  return data;
-}
-async function downloadBlobRange(blob, offset, size, log, signal) {
-  throwIfAborted(signal);
-  if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(size) || size < 0) {
-    throw new Error("BLOB range offset and size must be non-negative safe integers");
-  }
-  const chunks = blob.chunks ?? [];
-  const totalSize = chunks.reduce((total, chunk) => total + (chunk.size ?? 0), 0);
-  if (offset + size > totalSize) {
-    throw new Error(`BLOB range ${offset}..${offset + size} exceeds declared size ${totalSize}`);
-  }
-  if (size === 0) return new Uint8Array();
-  const uriCounts = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    if (chunk.uri != null) uriCounts.set(chunk.uri, (uriCounts.get(chunk.uri) ?? 0) + 1);
-  }
-  const rangeEnd = offset + size;
-  let chunkOffset = 0;
-  const reads = [];
-  for (const [index, chunk] of chunks.entries()) {
-    const chunkSize = chunk.size ?? 0;
-    const chunkEnd = chunkOffset + chunkSize;
-    const overlapStart = Math.max(offset, chunkOffset);
-    const overlapEnd = Math.min(rangeEnd, chunkEnd);
-    if (overlapStart < overlapEnd) {
-      reads.push(readChunkRange(
-        chunk,
-        index,
-        chunkOffset,
-        overlapStart - chunkOffset,
-        overlapEnd - overlapStart,
-        (uriCounts.get(chunk.uri ?? "") ?? 0) > 1,
-        log,
-        signal
-      ));
-    }
-    chunkOffset = chunkEnd;
-  }
-  const data = concatenate(await Promise.all(reads));
-  throwIfAborted(signal);
-  if (data.byteLength !== size) throw new Error("BLOB does not contain the complete requested range");
-  log?.("download blob completed", {
-    blob_id: blob.id,
-    chunk_count: chunks.length,
-    downloaded_bytes: data.byteLength,
-    range_offset: offset,
-    range_size: size
-  });
-  return data;
-}
-async function downloadBlob(blob, log, signal) {
-  const size = (blob.chunks ?? []).reduce((total, chunk) => total + (chunk.size ?? 0), 0);
-  return downloadBlobRange(blob, 0, size, log, signal);
-}
-async function downloadSerializedObject(object, blob, log, signal) {
-  throwIfAborted(signal);
-  const manifest = object.manifest;
-  if (manifest?.size == null || manifest.metadataSize == null) {
-    throw new Error("Serialized object manifest is missing size or metadata_size");
-  }
-  if (!Number.isSafeInteger(manifest.size) || manifest.size < 0) {
-    throw new Error("Serialized object size must be a non-negative safe integer");
-  }
-  if (!Number.isSafeInteger(manifest.metadataSize) || manifest.metadataSize < 0) {
-    throw new Error("Serialized object metadata_size must be a non-negative safe integer");
-  }
-  if (manifest.metadataSize > manifest.size) {
-    throw new Error("Serialized object metadata_size cannot exceed size");
-  }
-  if (typeof manifest.sha256Hash !== "string" || manifest.sha256Hash.length === 0) {
-    throw new Error("Serialized object manifest is missing sha256_hash");
-  }
-  const start = object.offset ?? 0;
-  const bytes = await downloadBlobRange(blob, start, manifest.size, log, signal);
-  throwIfAborted(signal);
-  const hash = createHash2("sha256").update(bytes).digest("hex");
-  if (hash !== manifest.sha256Hash) {
-    throw new Error(`Serialized object hash mismatch: expected ${manifest.sha256Hash}, got ${hash}`);
-  }
-  return {
-    metadata: bytes.subarray(0, manifest.metadataSize),
-    data: bytes.subarray(manifest.metadataSize),
-    contentType: manifest.contentType,
-    encoding: manifest.encoding
-  };
-}
-function deserializeValueFromProtocol(value) {
-  if (enumIs(value.encoding, "SERIALIZED_OBJECT_ENCODING_RAW", 5)) {
-    return new File(value.data, value.contentType ?? "application/octet-stream");
-  }
-  if (enumIs(value.encoding, "SERIALIZED_OBJECT_ENCODING_UTF8_TEXT", 2)) {
-    return new TextDecoder("utf-8", { fatal: true }).decode(value.data);
-  }
-  if (enumIs(value.encoding, "SERIALIZED_OBJECT_ENCODING_UTF8_JSON", 1) || value.contentType?.toLowerCase().includes("json")) {
-    return deserializeJSON(value.data);
-  }
-  throw new Error(`Unsupported serialized object encoding '${String(value.encoding)}'`);
-}
-function prepareSerializedObject(value, offset = 0, sourceFunctionCallId) {
-  const serialized = serializeValue(value);
-  const metadata = new TextEncoder().encode(JSON.stringify({
-    format: "tensorlake.typescript.value.v1"
-  }));
-  const bytes = concatenate([metadata, serialized.data]);
-  return {
-    bytes,
-    object: {
-      offset,
-      manifest: {
-        encoding: serialized.encoding === "json" ? "SERIALIZED_OBJECT_ENCODING_UTF8_JSON" : "SERIALIZED_OBJECT_ENCODING_RAW",
-        encodingVersion: 0,
-        size: bytes.byteLength,
-        metadataSize: metadata.byteLength,
-        sha256Hash: createHash2("sha256").update(bytes).digest("hex"),
-        ...serialized.encoding === "raw" ? { contentType: serialized.contentType } : {},
-        sourceFunctionCallId
-      }
-    }
-  };
-}
-function prepareTextObject(value) {
-  const bytes = new TextEncoder().encode(value);
-  return {
-    bytes,
-    object: {
-      offset: 0,
-      manifest: {
-        encoding: "SERIALIZED_OBJECT_ENCODING_UTF8_TEXT",
-        encodingVersion: 0,
-        size: bytes.byteLength,
-        metadataSize: 0,
-        sha256Hash: createHash2("sha256").update(bytes).digest("hex")
-      }
-    }
-  };
-}
-async function uploadChunk(chunk, data, index, offset, log, signal) {
-  throwIfAborted(signal);
-  if (!chunk.uri) throw new Error("Writable BLOB chunk has no URI");
-  const fields = {
-    chunk_index: index,
-    chunk_offset: offset,
-    upload_bytes: data.byteLength,
-    chunk_capacity: chunk.size ?? 0,
-    uri_kind: uriKind(chunk.uri)
-  };
-  const startedAt = Date.now();
-  log?.("upload chunk starting", fields);
-  if (chunk.uri.startsWith("file://")) {
-    const filePath = fileURLToPath(chunk.uri);
-    let file;
-    try {
-      file = await open(filePath, "r+");
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-      file = await open(filePath, "w+");
-    }
-    try {
-      throwIfAborted(signal);
-      await file.write(data, 0, data.byteLength, offset);
-      throwIfAborted(signal);
-    } finally {
-      await file.close();
-    }
-    log?.("upload chunk completed", { ...fields, duration_ms: Date.now() - startedAt });
-    return { ...chunk, size: data.byteLength };
-  }
-  const response = await fetchWithRetries(chunk.uri, {
-    method: "PUT",
-    ...data.byteLength === 0 ? {} : {
-      body: Uint8Array.from(data).buffer
-    }
-  }, log, fields, signal);
-  throwIfAborted(signal);
-  const uploaded = {
-    ...chunk,
-    size: data.byteLength,
-    etag: response.headers.get("etag") ?? void 0
-  };
-  log?.("upload chunk completed", {
-    ...fields,
-    status_code: response.status,
-    has_etag: uploaded.etag != null,
-    duration_ms: Date.now() - startedAt
-  });
-  return uploaded;
-}
-async function uploadBlob(blob, data, log, signal) {
-  throwIfAborted(signal);
-  const chunks = blob.chunks ?? [];
-  const capacity = chunks.reduce((total, chunk) => total + (chunk.size ?? 0), 0);
-  if (data.byteLength > capacity) throw new Error(`BLOB capacity ${capacity} is smaller than ${data.byteLength}`);
-  let offset = 0;
-  const uploaded = [];
-  for (const [index, chunk] of chunks.entries()) {
-    const size = Math.min(chunk.size ?? 0, data.byteLength - offset);
-    if (size <= 0) break;
-    uploaded.push(await uploadChunk(
-      chunk,
-      data.subarray(offset, offset + size),
-      index,
-      offset,
-      log,
-      signal
-    ));
-    offset += size;
-  }
-  if (data.byteLength === 0 && chunks.length > 0) {
-    uploaded.push(await uploadChunk(chunks[0], data, 0, 0, log, signal));
-  }
-  throwIfAborted(signal);
-  if (offset !== data.byteLength) throw new Error(`Only uploaded ${offset} of ${data.byteLength} bytes`);
-  log?.("upload blob completed", {
-    blob_id: blob.id,
-    chunk_count: uploaded.length,
-    uploaded_bytes: data.byteLength
-  });
-  return { ...blob, chunks: uploaded };
-}
-function joinPrepared(values) {
-  return concatenate(values.map((value) => value.bytes));
-}
-
-// src/function-executor/user-events.ts
-import { randomUUID as randomUUID2 } from "crypto";
-function printCloudEvent(data, options = {}) {
-  writeStructuredOutput("stdout", () => ({
-    specversion: "1.0",
-    id: randomUUID2(),
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    type: options.type ?? "ai.tensorlake.event",
-    source: options.source ?? "/tensorlake/function_executor/events",
-    data,
-    ...options.message == null ? {} : { message: options.message }
-  }));
-}
-
-// src/function-executor/allocation.ts
-installPromiseInstrumentation();
-var OK = 0;
-var NOT_FOUND = 5;
-var REPLAY_STRICT = /* @__PURE__ */ new Set(["REPLAY_MODE_STRICT", 1]);
-var OUTCOME_SUCCESS = /* @__PURE__ */ new Set(["ALLOCATION_OUTCOME_CODE_SUCCESS", 1]);
-var OUTCOME_FAILURE = /* @__PURE__ */ new Set(["ALLOCATION_OUTCOME_CODE_FAILURE", 2]);
-var WATCHER_TIMED_OUT = /* @__PURE__ */ new Set(["FUNCTION_CALL_WATCHER_STATUS_TIMEDOUT", 2]);
-var MAX_REDUCE_CALLS_PER_PLAN = 512;
-var nativeStructuredClone = globalThis.structuredClone;
-function statusError(status2, fallback) {
-  if (status2 == null || (status2.code ?? OK) === OK) return void 0;
-  return new FunctionError(status2.message || fallback);
-}
-function validatedEventLogClock(response, requestedAfterClock, createError) {
-  if (response.entries != null && !Array.isArray(response.entries)) {
-    throw createError("Allocation event log returned a non-array entries field");
-  }
-  const responseClock = Number(response.lastClock ?? requestedAfterClock);
-  if (!Number.isFinite(responseClock) || !Number.isSafeInteger(responseClock) || responseClock < 0) {
-    throw createError(
-      `Allocation event log returned invalid clock '${String(response.lastClock)}'`
-    );
-  }
-  if (responseClock < requestedAfterClock) {
-    throw createError(
-      `Allocation event log moved backwards from clock ${requestedAfterClock} to ${responseClock}`
-    );
-  }
-  if (response.hasMore && responseClock === requestedAfterClock) {
-    throw createError(
-      `Allocation event log reported more entries without advancing clock ${requestedAfterClock}`
-    );
-  }
-  if ((response.entries?.length ?? 0) > 0 && responseClock === requestedAfterClock) {
-    throw createError(
-      `Allocation event log returned entries without advancing clock ${requestedAfterClock}`
-    );
-  }
-  const eventFields = [
-    "functionCallCreated",
-    "functionCallWatcherCreated",
-    "functionCallWatcherResult"
-  ];
-  let previousEntryClock = requestedAfterClock;
-  for (const [index, entry] of (response.entries ?? []).entries()) {
-    if (entry == null || typeof entry !== "object") {
-      throw createError(`Allocation event log entry ${index} is not an object`);
-    }
-    const presentFields = eventFields.filter((field) => entry[field] != null);
-    if (presentFields.length !== 1) {
-      throw createError(
-        `Allocation event log entry ${index} has ${presentFields.length} recognized payloads; expected exactly one`
-      );
-    }
-    const entryClock = Number(entry.clock);
-    if (!Number.isSafeInteger(entryClock) || entryClock <= previousEntryClock || entryClock > responseClock) {
-      throw createError(
-        `Allocation event log entry ${index} has invalid clock '${String(entry.clock)}' after ${previousEntryClock} with page clock ${responseClock}`
-      );
-    }
-    previousEntryClock = entryClock;
-  }
-  return responseClock;
-}
-function durableHash(values) {
-  const hash = createHash3("sha256");
-  for (const value of values) {
-    const bytes = Buffer.from(value, "utf8");
-    const length = Buffer.alloc(8);
-    length.writeBigUInt64BE(BigInt(bytes.byteLength));
-    hash.update(length);
-    hash.update(bytes);
-    hash.update("|");
-  }
-  return hash.digest("hex");
-}
-function protocolTimestamp(date) {
-  const milliseconds = date.getTime();
-  return { seconds: Math.floor(milliseconds / 1e3), nanos: milliseconds % 1e3 * 1e6 };
-}
-function parseHTTPMessage(data) {
-  const marker = Buffer.from("\r\n\r\n");
-  const bytes = Buffer.from(data);
-  const split = bytes.indexOf(marker);
-  if (split < 0) throw new DeserializationError("Invalid message/http application input");
-  const lines = bytes.subarray(0, split).toString("utf8").split("\r\n");
-  lines.shift();
-  const headers = {};
-  for (const line of lines) {
-    const colon = line.indexOf(":");
-    if (colon > 0) headers[line.slice(0, colon).trim().toLowerCase()] = line.slice(colon + 1).trim();
-  }
-  return { headers, body: new Uint8Array(bytes.subarray(split + marker.byteLength)) };
-}
-async function deserializeApplicationArguments(definition, payload) {
-  let data = payload.data;
-  let suppliedContentType = payload.contentType;
-  let hasExplicitContentType = payload.contentType != null;
-  if (suppliedContentType?.toLowerCase().startsWith("message/http")) {
-    const parsed = parseHTTPMessage(data);
-    data = parsed.body;
-    const bodyContentType = parsed.headers["content-type"];
-    hasExplicitContentType = bodyContentType != null;
-    suppliedContentType = bodyContentType;
-  }
-  if (definition.parameters.length === 0) return { args: [] };
-  const firstParameter = definition.parameters[0];
-  if (definition.parameters.length === 1 && firstParameter?.schema._httpBody) {
-    return { args: [new HttpBody(data, suppliedContentType)] };
-  }
-  const contentType = suppliedContentType ?? "application/json";
-  if (contentType.toLowerCase().startsWith("multipart/form-data")) {
-    let form;
-    try {
-      form = await new Response(Uint8Array.from(data).buffer, {
-        headers: { "content-type": contentType }
-      }).formData();
-    } catch (error) {
-      throw new DeserializationError("Failed to deserialize multipart application input", { cause: error });
-    }
-    const args = [];
-    for (const [index, parameter] of definition.parameters.entries()) {
-      const part = form.get(parameter.name) ?? form.get(String(index));
-      if (part == null) {
-        args.push(void 0);
-      } else if (parameter.schema._file || parameter.schema._httpBody) {
-        const bytes = typeof part === "string" ? new TextEncoder().encode(part) : new Uint8Array(await part.arrayBuffer());
-        const partContentType = typeof part === "string" ? "application/octet-stream" : part.type || "application/octet-stream";
-        args.push(parameter.schema._httpBody ? new HttpBody(bytes, partContentType) : new File(bytes, partContentType));
-      } else {
-        try {
-          const bytes = typeof part === "string" ? new TextEncoder().encode(part) : new Uint8Array(await part.arrayBuffer());
-          args.push(deserializeJSON(bytes));
-        } catch (error) {
-          if (error instanceof DeserializationError) throw error;
-          throw new DeserializationError(
-            `Failed to deserialize multipart argument '${parameter.name}' as JSON`,
-            { cause: error }
-          );
-        }
-      }
-    }
-    return { args };
-  }
-  if (data.byteLength === 0 && (!firstParameter?.schema._file || !hasExplicitContentType)) {
-    return { args: [] };
-  }
-  if (firstParameter?.schema._file) return { args: [new File(data, contentType)] };
-  if (!contentType.toLowerCase().includes("json")) {
-    throw new DeserializationError(
-      `Expected application/json input for '${firstParameter?.name ?? "argument"}', got ${contentType}`
-    );
-  }
-  return { args: [deserializeJSON(data)] };
-}
-var PASSIVE_ASYNC_RESOURCE_TYPES = /* @__PURE__ */ new Set([
-  "PIPEWRAP",
-  "PIPESERVERWRAP",
-  "SIGNALWRAP",
-  "TCPSERVERWRAP",
-  "TCPWRAP",
-  "TLSWRAP",
-  "TTYWRAP",
-  "UDPWRAP"
-]);
-var ReplayCausality = class {
-  constructor(onQuiescent) {
-    this.onQuiescent = onQuiescent;
-    this.hook = createHook({
-      init: (asyncId, type, triggerAsyncId, resource) => {
-        if (this.stopped) return;
-        const triggerPromise = this.resources.get(triggerAsyncId)?.promise?.deref();
-        const resumesDetachedDurable = type === "PROMISE" && triggerPromise != null && isDetachedDurableThenable(triggerPromise);
-        const children = this.children.get(triggerAsyncId) ?? /* @__PURE__ */ new Set();
-        children.add(asyncId);
-        this.children.set(triggerAsyncId, children);
-        if (type === "PROMISE" && typeof resource === "object" && resource != null) {
-          this.promiseIds.set(resource, asyncId);
-        }
-        const triggerOwners = new Set(this.owners.get(triggerAsyncId) ?? []);
-        this.resources.set(asyncId, {
-          type,
-          triggerAsyncId,
-          promise: type === "PROMISE" && typeof resource === "object" && resource != null ? new WeakRef(resource) : void 0,
-          pending: true
-        });
-        if (resumesDetachedDurable) {
-          this.nativeDurableAssimilations.add(asyncId);
-          this.promiseAggregateAssimilationScopes.at(-1)?.add(asyncId);
-          this.suspendDurableAssimilation(asyncId);
-        }
-        if (this.suppressOwnership) return;
-        const inherited = /* @__PURE__ */ new Set([
-          ...this.owners.get(executionAsyncId2()) ?? [],
-          ...triggerOwners
-        ]);
-        for (const token of inherited) this.addTokenToSubtree(asyncId, token);
-      },
-      promiseResolve: (asyncId) => {
-        if (this.stopped) return;
-        this.notifyPromiseSettlement(asyncId);
-        if (this.nativeDurableAssimilations.delete(asyncId)) {
-          this.resumeDurableAssimilation(asyncId);
-        }
-        if (this.explicitDurableAssimilations.delete(asyncId)) {
-          this.resumeDurableAssimilation(asyncId);
-        }
-        this.settleMixedPromiseProducerGroups(asyncId);
-        const currentOwners = this.owners.get(executionAsyncId2());
-        if (currentOwners != null) {
-          for (const token of currentOwners) this.addTokenToSubtree(asyncId, token);
-        }
-        this.setResourcePending(asyncId, false);
-        this.scheduleCheck();
-      },
-      destroy: (asyncId) => {
-        if (this.stopped) return;
-        this.notifyPromiseSettlement(asyncId);
-        if (this.nativeDurableAssimilations.delete(asyncId)) {
-          this.detachDurableAssimilation(asyncId);
-        }
-        if (this.explicitDurableAssimilations.delete(asyncId)) {
-          this.detachDurableAssimilation(asyncId);
-        }
-        this.settleMixedPromiseProducerGroups(asyncId);
-        this.setResourcePending(asyncId, false);
-        this.releaseDestroyedResource(asyncId);
-        this.scheduleCheck();
-      }
-    });
-    this.hook.enable();
-  }
-  hook;
-  children = /* @__PURE__ */ new Map();
-  resources = /* @__PURE__ */ new Map();
-  owners = /* @__PURE__ */ new Map();
-  provenance = /* @__PURE__ */ new Map();
-  tokenResources = /* @__PURE__ */ new Map();
-  tokenProducers = /* @__PURE__ */ new Map();
-  promiseIds = /* @__PURE__ */ new WeakMap();
-  excludedRoots = /* @__PURE__ */ new Set();
-  durableAssimilations = /* @__PURE__ */ new Map();
-  nativeDurableAssimilations = /* @__PURE__ */ new Set();
-  explicitDurableAssimilations = /* @__PURE__ */ new Set();
-  promiseAggregateAssimilationScopes = [];
-  promiseSettlementObservers = /* @__PURE__ */ new Map();
-  mixedPromiseProducerGroups = /* @__PURE__ */ new Set();
-  nextToken = 1;
-  checkScheduled = false;
-  checkHandle;
-  suppressOwnership = false;
-  stopped = false;
-  runRoot(callback) {
-    const resource = new AsyncResource("TensorlakeReplayCausality");
-    let result;
-    resource.runInAsyncScope(() => {
-      this.beginCurrentContinuation();
-      result = callback();
-      this.excludePromise(result);
-    });
-    resource.emitDestroy();
-    return result;
-  }
-  beginCurrentContinuation() {
-    if (this.stopped) return;
-    const asyncId = executionAsyncId2();
-    this.excludedRoots.delete(asyncId);
-    this.addTokenToSubtree(asyncId, this.nextToken);
-    this.nextToken += 1;
-    this.scheduleCheck();
-  }
-  excludePromise(promise) {
-    const asyncId = this.promiseIds.get(promise);
-    if (asyncId == null) return;
-    this.excludedRoots.add(asyncId);
-    this.removeOwnersFromSubtree(asyncId);
-    this.scheduleCheck();
-  }
-  suspendDurableAssimilation(asyncId) {
-    if (this.stopped) return false;
-    const count = this.durableAssimilations.get(asyncId) ?? 0;
-    this.durableAssimilations.set(asyncId, count + 1);
-    if (count === 0) {
-      this.excludedRoots.add(asyncId);
-      this.removeOwnersFromSubtree(asyncId);
-    }
-    this.scheduleCheck();
-    return true;
-  }
-  resumeDurableAssimilation(asyncId) {
-    if (this.stopped) return;
-    const count = this.durableAssimilations.get(asyncId);
-    if (count == null) return;
-    if (count > 1) {
-      this.durableAssimilations.set(asyncId, count - 1);
-      return;
-    }
-    this.durableAssimilations.delete(asyncId);
-    this.excludedRoots.delete(asyncId);
-    const currentOwners = this.owners.get(executionAsyncId2());
-    if (currentOwners != null) {
-      for (const token of currentOwners) this.addTokenToSubtree(asyncId, token);
-    }
-  }
-  detachDurableAssimilation(asyncId) {
-    if (this.stopped) return;
-    const count = this.durableAssimilations.get(asyncId);
-    if (count == null) return;
-    if (count > 1) {
-      this.durableAssimilations.set(asyncId, count - 1);
-      return;
-    }
-    this.durableAssimilations.delete(asyncId);
-    this.excludedRoots.delete(asyncId);
-    this.scheduleCheck();
-  }
-  hasPendingDurableAssimilation() {
-    return this.durableAssimilations.size > 0;
-  }
-  hasPendingProducer() {
-    if (this.mixedPromiseProducerGroups.size > 0) return true;
-    for (const producers of this.tokenProducers.values()) {
-      if (producers.size > 0) return true;
-    }
-    return false;
-  }
-  requestCheck() {
-    this.scheduleCheck();
-  }
-  trackMixedPromiseRace(promise, producers = [promise]) {
-    if (this.stopped) return;
-    const producerIds = /* @__PURE__ */ new Set();
-    for (const producer of producers) {
-      const asyncId = this.promiseIds.get(producer);
-      if (asyncId == null) continue;
-      if (this.resources.get(asyncId)?.pending !== true) {
-        this.scheduleCheck();
-        return;
-      }
-      producerIds.add(asyncId);
-    }
-    if (producerIds.size > 0) this.mixedPromiseProducerGroups.add(producerIds);
-    this.scheduleCheck();
-  }
-  trackPromiseSettlement(promise, onSettled) {
-    if (this.stopped) return false;
-    const asyncId = this.promiseIds.get(promise);
-    if (asyncId == null) return false;
-    if (this.resources.get(asyncId)?.pending !== true) {
-      onSettled();
-      return true;
-    }
-    const observers = this.promiseSettlementObservers.get(asyncId) ?? /* @__PURE__ */ new Set();
-    observers.add(onSettled);
-    this.promiseSettlementObservers.set(asyncId, observers);
-    return true;
-  }
-  trackDurablePromiseConsumption(promise) {
-    if (this.stopped) return;
-    const asyncId = this.promiseIds.get(promise);
-    if (asyncId == null || this.resources.get(asyncId)?.pending !== true || this.nativeDurableAssimilations.has(asyncId) || this.explicitDurableAssimilations.has(asyncId)) {
-      return;
-    }
-    this.explicitDurableAssimilations.add(asyncId);
-    this.promiseAggregateAssimilationScopes.at(-1)?.add(asyncId);
-    this.suspendDurableAssimilation(asyncId);
-  }
-  runPromiseAggregateConstruction(callback) {
-    const aggregateAssimilations = /* @__PURE__ */ new Set();
-    this.promiseAggregateAssimilationScopes.push(aggregateAssimilations);
-    try {
-      return callback();
-    } finally {
-      this.promiseAggregateAssimilationScopes.pop();
-      this.detachPromiseAggregateAssimilations(aggregateAssimilations);
-    }
-  }
-  runWithoutOwnership(callback) {
-    if (this.stopped) return callback();
-    const previous = this.suppressOwnership;
-    this.suppressOwnership = true;
-    try {
-      return callback();
-    } finally {
-      this.suppressOwnership = previous;
-    }
-  }
-  stop() {
-    if (this.stopped) return;
-    this.stopped = true;
-    this.hook.disable();
-    if (this.checkHandle != null) clearImmediate(this.checkHandle);
-    this.checkHandle = void 0;
-    this.children.clear();
-    this.resources.clear();
-    this.owners.clear();
-    this.provenance.clear();
-    this.tokenResources.clear();
-    this.tokenProducers.clear();
-    this.durableAssimilations.clear();
-    this.nativeDurableAssimilations.clear();
-    this.explicitDurableAssimilations.clear();
-    this.promiseAggregateAssimilationScopes.length = 0;
-    this.promiseSettlementObservers.clear();
-    this.mixedPromiseProducerGroups.clear();
-  }
-  notifyPromiseSettlement(asyncId) {
-    const observers = this.promiseSettlementObservers.get(asyncId);
-    if (observers == null) return;
-    this.promiseSettlementObservers.delete(asyncId);
-    for (const observer of observers) observer();
-  }
-  settleMixedPromiseProducerGroups(asyncId) {
-    for (const group of [...this.mixedPromiseProducerGroups]) {
-      if (group.has(asyncId)) this.mixedPromiseProducerGroups.delete(group);
-    }
-  }
-  detachPromiseAggregateAssimilations(assimilations) {
-    for (const asyncId of assimilations) {
-      if (this.nativeDurableAssimilations.delete(asyncId)) {
-        this.detachDurableAssimilation(asyncId);
-      }
-      if (this.explicitDurableAssimilations.delete(asyncId)) {
-        this.detachDurableAssimilation(asyncId);
-      }
-    }
-    assimilations.clear();
-  }
-  addTokenToSubtree(asyncId, token) {
-    if (this.excludedRoots.has(asyncId)) return;
-    const owners = this.owners.get(asyncId) ?? /* @__PURE__ */ new Set();
-    if (!owners.has(token)) {
-      owners.add(token);
-      this.owners.set(asyncId, owners);
-      const provenance = this.provenance.get(asyncId) ?? /* @__PURE__ */ new Set();
-      provenance.add(token);
-      this.provenance.set(asyncId, provenance);
-      const tokenResources = this.tokenResources.get(token) ?? /* @__PURE__ */ new Set();
-      tokenResources.add(asyncId);
-      this.tokenResources.set(token, tokenResources);
-      const resource = this.resources.get(asyncId);
-      if (resource?.pending && this.isProducer(resource, token)) {
-        const producers = this.tokenProducers.get(token) ?? /* @__PURE__ */ new Set();
-        producers.add(asyncId);
-        this.tokenProducers.set(token, producers);
-      }
-    }
-    for (const child of this.children.get(asyncId) ?? []) {
-      this.addTokenToSubtree(child, token);
-    }
-  }
-  isProducer(resource, token) {
-    if (resource.type === "PROMISE") {
-      return !(this.provenance.get(resource.triggerAsyncId)?.has(token) ?? false);
-    }
-    return !PASSIVE_ASYNC_RESOURCE_TYPES.has(resource.type);
-  }
-  setResourcePending(asyncId, pending) {
-    const resource = this.resources.get(asyncId);
-    if (resource == null || resource.pending === pending) return;
-    resource.pending = pending;
-    for (const token of this.owners.get(asyncId) ?? []) {
-      const producers = this.tokenProducers.get(token);
-      if (pending && this.isProducer(resource, token)) {
-        const next = producers ?? /* @__PURE__ */ new Set();
-        next.add(asyncId);
-        this.tokenProducers.set(token, next);
-      } else {
-        producers?.delete(asyncId);
-      }
-    }
-  }
-  removeOwnersFromSubtree(asyncId) {
-    this.removeResourceOwnership(asyncId);
-    for (const child of this.children.get(asyncId) ?? []) {
-      this.removeOwnersFromSubtree(child);
-    }
-  }
-  removeResourceOwnership(asyncId) {
-    const owners = this.owners.get(asyncId);
-    if (owners == null) return;
-    for (const token of owners) {
-      const resources = this.tokenResources.get(token);
-      resources?.delete(asyncId);
-      if (resources?.size === 0) this.tokenResources.delete(token);
-      const producers = this.tokenProducers.get(token);
-      producers?.delete(asyncId);
-      if (producers?.size === 0) this.tokenProducers.delete(token);
-    }
-    this.owners.delete(asyncId);
-  }
-  releaseDestroyedResource(asyncId) {
-    const resource = this.resources.get(asyncId);
-    if (resource == null) return;
-    this.resources.delete(asyncId);
-    this.excludedRoots.delete(asyncId);
-    this.removeResourceOwnership(asyncId);
-    this.provenance.delete(asyncId);
-    const siblings = this.children.get(resource.triggerAsyncId);
-    siblings?.delete(asyncId);
-    if (siblings?.size === 0) this.children.delete(resource.triggerAsyncId);
-    this.children.delete(asyncId);
-  }
-  scheduleCheck() {
-    if (this.stopped || this.checkScheduled) return;
-    this.checkScheduled = true;
-    const previous = this.suppressOwnership;
-    this.suppressOwnership = true;
-    try {
-      this.checkHandle = setImmediate(() => {
-        this.checkScheduled = false;
-        this.checkHandle = void 0;
-        this.onQuiescent();
-      });
-    } finally {
-      this.suppressOwnership = previous;
-    }
-  }
-};
-var ReplayAwarePromise = class extends Promise {
-  causality;
-  constructor(source, causality) {
-    let bridge;
-    super((resolve, reject) => {
-      bridge = source.then(resolve, reject);
-    });
-    this.causality = causality;
-    registerDurableThenable(this);
-    causality.excludePromise(source);
-    causality.excludePromise(this);
-    if (bridge != null) causality.excludePromise(bridge);
-  }
-  static get [Symbol.species]() {
-    return Promise;
-  }
-  then(onfulfilled, onrejected) {
-    const assimilationId = executionAsyncId2();
-    const assimilationSuspended = this.causality.suspendDurableAssimilation(assimilationId);
-    let assimilationDetached = false;
-    const aggregateAssimilation = registerDurableAssimilation(this, () => {
-      if (!assimilationSuspended || assimilationDetached) return;
-      assimilationDetached = true;
-      this.causality.detachDurableAssimilation(assimilationId);
-    });
-    const continuation = super.then(
-      (value) => {
-        this.causality.beginCurrentContinuation();
-        aggregateAssimilation.finish();
-        if (assimilationSuspended && !assimilationDetached) {
-          this.causality.resumeDurableAssimilation(assimilationId);
-        }
-        if (onfulfilled == null) return value;
-        return onfulfilled(value);
-      },
-      (reason) => {
-        this.causality.beginCurrentContinuation();
-        aggregateAssimilation.finish();
-        if (assimilationSuspended && !assimilationDetached) {
-          this.causality.resumeDurableAssimilation(assimilationId);
-        }
-        if (onrejected == null) throw reason;
-        return onrejected(reason);
-      }
-    );
-    aggregateAssimilation.link(continuation);
-    this.causality.excludePromise(continuation);
-    return continuation;
-  }
-  [DURABLE_PROMISE_INTERNAL_THEN](onfulfilled, onrejected) {
-    const continuation = super.then(onfulfilled, onrejected);
-    registerDurableThenable(continuation, this);
-    this.causality.excludePromise(continuation);
-    return continuation;
-  }
-  [DURABLE_PROMISE_OBSERVER](onfulfilled, onrejected) {
-    const observation = super.then(onfulfilled, onrejected);
-    this.causality.excludePromise(observation);
-    void observation.catch(() => void 0);
-  }
-};
-var ReplayHistory = class {
-  entries;
-  calls = [];
-  watchers = [];
-  availableResults = /* @__PURE__ */ new Map();
-  resultWaiters = /* @__PURE__ */ new Map();
-  endWaiters = [];
-  createdWatcherIds = /* @__PURE__ */ new Set();
-  releasedResultIds = /* @__PURE__ */ new Set();
-  expectedCallIds = /* @__PURE__ */ new Set();
-  expectedWatcherIds = /* @__PURE__ */ new Set();
-  causality;
-  // A replayed result may still be downloading before it can resume user code.
-  activeResultResolutions = 0;
-  callCursor = 0;
-  watcherCursor = 0;
-  prefixCursor = 0;
-  mismatch;
-  constructor(entries) {
-    this.causality = new ReplayCausality(() => this.failBlockedResultWithoutProducer());
-    this.entries = entries.map((entry) => {
-      if (entry.functionCallWatcherResult != null) {
-        return { kind: "result", event: entry.functionCallWatcherResult, consumed: false };
-      }
-      if (entry.functionCallCreated != null) {
-        const replayEntry = {
-          kind: "call",
-          event: entry.functionCallCreated,
-          consumed: false
-        };
-        this.calls.push(replayEntry);
-        return replayEntry;
-      }
-      if (entry.functionCallWatcherCreated != null) {
-        const replayEntry = {
-          kind: "watcher",
-          event: entry.functionCallWatcherCreated,
-          consumed: false
-        };
-        this.watchers.push(replayEntry);
-        return replayEntry;
-      }
-      return { kind: "unknown", event: entry, consumed: false };
-    });
-  }
-  async takeOrdered(kind, id) {
-    this.advancePrefix();
-    const entries = kind === "call" ? this.calls : this.watchers;
-    const cursor = kind === "call" ? this.callCursor : this.watcherCursor;
-    const expectedIds = kind === "call" ? this.expectedCallIds : this.expectedWatcherIds;
-    if (cursor >= entries.length) {
-      expectedIds.delete(id);
-      if (this.prefixCursor === this.entries.length) return void 0;
-      const blocked = this.entries[this.prefixCursor];
-      if (kind !== "call" || blocked.kind !== "watcher" || !this.expectedWatcherIds.has(String(blocked.event.functionCallId ?? ""))) {
-        this.fail(
-          `Unexpected ${kind} event for ${id} before replay ${blocked.kind} event ${String(blocked.event.functionCallId ?? "")}`
-        );
-      }
-      const waiter = deferred();
-      this.endWaiters.push(waiter);
-      await waiter.promise;
-      this.assertNoMismatch();
-      return void 0;
-    }
-    const entry = entries[cursor];
-    if (kind === "call") this.callCursor += 1;
-    else this.watcherCursor += 1;
-    if (entry.event.functionCallId !== id) {
-      this.fail(`Expected replay ${kind} event for ${id}`);
-    }
-    expectedIds.delete(id);
-    entry.consumed = true;
-    if (kind === "watcher") {
-      this.createdWatcherIds.add(id);
-    }
-    this.advancePrefix();
-    return entry.event;
-  }
-  async takeResult(id) {
-    this.advancePrefix();
-    const available = this.availableResults.get(id);
-    if (available != null && available.length > 0) {
-      const result2 = available.shift();
-      if (result2 != null) this.activeResultResolutions += 1;
-      return result2;
-    }
-    if (this.prefixCursor === this.entries.length) return void 0;
-    const blocked = this.entries[this.prefixCursor];
-    const blockedId = String(blocked.event.functionCallId ?? "");
-    const hasProducer = blocked.kind === "call" ? this.expectedCallIds.has(blockedId) : blocked.kind === "watcher" ? this.expectedWatcherIds.has(blockedId) : false;
-    const waiter = deferred();
-    const waiters = this.resultWaiters.get(id) ?? [];
-    waiters.push(waiter);
-    this.resultWaiters.set(id, waiters);
-    if (!hasProducer) this.causality.requestCheck();
-    const result = await waiter.promise;
-    if (result != null) this.activeResultResolutions += 1;
-    return result;
-  }
-  completeResultResolution() {
-    if (this.activeResultResolutions === 0) return;
-    this.activeResultResolutions -= 1;
-    this.causality.requestCheck();
-  }
-  runCausalHandler(callback) {
-    return this.causality.runRoot(callback);
-  }
-  wrapDurableResult(source) {
-    return new ReplayAwarePromise(source, this.causality);
-  }
-  trackMixedPromiseRace(promise, producers) {
-    this.causality.trackMixedPromiseRace(promise, producers);
-  }
-  trackPromiseSettlement(promise, onSettled) {
-    return this.causality.trackPromiseSettlement(promise, onSettled);
-  }
-  trackDurablePromiseConsumption(promise) {
-    this.causality.trackDurablePromiseConsumption(promise);
-  }
-  runPromiseAggregateConstruction(callback) {
-    return this.causality.runPromiseAggregateConstruction(callback);
-  }
-  runWithoutCausalOwnership(callback) {
-    return this.causality.runWithoutOwnership(callback);
-  }
-  dispose() {
-    this.causality.stop();
-  }
-  expectCall(id) {
-    this.expectedCallIds.add(id);
-  }
-  expectWatcher(id) {
-    this.expectedWatcherIds.add(id);
-  }
-  abandonCall(id) {
-    this.abandonOrdered("call", id);
-  }
-  abandonWatcher(id) {
-    this.abandonOrdered("watcher", id);
-  }
-  abandonOrdered(kind, id) {
-    const expectedIds = kind === "call" ? this.expectedCallIds : this.expectedWatcherIds;
-    expectedIds.delete(id);
-    const hasWaiters = this.endWaiters.length > 0 || [...this.resultWaiters.values()].some((waiters) => waiters.length > 0);
-    if (this.prefixCursor >= this.entries.length || !hasWaiters) return;
-    const blocked = this.entries[this.prefixCursor];
-    if (blocked.kind === kind && blocked.event.functionCallId === id) {
-      this.fail(`Replay ${kind} event for ${id} can no longer be created`);
-    }
-  }
-  failBlockedResultWithoutProducer() {
-    if (this.activeResultResolutions > 0) return;
-    if (!this.causality.hasPendingDurableAssimilation()) return;
-    if (this.causality.hasPendingProducer()) return;
-    if (this.prefixCursor >= this.entries.length) return;
-    if (![...this.resultWaiters.values()].some((waiters) => waiters.length > 0)) return;
-    const blocked = this.entries[this.prefixCursor];
-    const blockedId = String(blocked.event.functionCallId ?? "");
-    const hasProducer = blocked.kind === "call" ? this.expectedCallIds.has(blockedId) : blocked.kind === "watcher" ? this.expectedWatcherIds.has(blockedId) : false;
-    if (!hasProducer) {
-      this.recordMismatch(
-        `Replay result is blocked behind unreachable ${blocked.kind} event ${blockedId}`
-      );
-    }
-  }
-  hasAvailableResult(id) {
-    return (this.availableResults.get(id)?.length ?? 0) > 0;
-  }
-  assertNoMismatch() {
-    if (this.mismatch != null) throw this.mismatch;
-  }
-  assertConsumed() {
-    this.assertNoMismatch();
-    this.advancePrefix();
-    if (this.prefixCursor !== this.entries.length) {
-      throw new ReplayMismatchError("Function completed before its durable event history was consumed");
-    }
-  }
-  advancePrefix() {
-    this.assertNoMismatch();
-    while (this.prefixCursor < this.entries.length) {
-      const entry = this.entries[this.prefixCursor];
-      if (entry.kind === "unknown") {
-        this.fail("Replay history contains an unknown allocation event");
-      }
-      if (entry.kind === "call" || entry.kind === "watcher") {
-        if (!entry.consumed) return;
-        this.prefixCursor += 1;
-        continue;
-      }
-      entry.consumed = true;
-      this.prefixCursor += 1;
-      this.releaseResult(entry.event);
-    }
-    for (const waiter of this.endWaiters.splice(0)) waiter.resolve();
-    for (const waiters of this.resultWaiters.values()) {
-      for (const waiter of waiters) waiter.resolve(void 0);
-    }
-    this.resultWaiters.clear();
-  }
-  releaseResult(event) {
-    const id = String(event.functionCallId ?? "");
-    if (!this.createdWatcherIds.has(id)) {
-      this.fail(`Replay watcher result for ${id} appeared before its watcher was created`);
-    }
-    if (this.releasedResultIds.has(id)) {
-      this.fail(`Replay history contains duplicate watcher results for ${id}`);
-    }
-    this.releasedResultIds.add(id);
-    const waiter = this.resultWaiters.get(id)?.shift();
-    if (waiter != null) {
-      waiter.resolve(event);
-      if (this.resultWaiters.get(id)?.length === 0) this.resultWaiters.delete(id);
-      return;
-    }
-    const available = this.availableResults.get(id) ?? [];
-    available.push(event);
-    this.availableResults.set(id, available);
-  }
-  fail(message) {
-    throw this.recordMismatch(message);
-  }
-  recordMismatch(message) {
-    this.mismatch ??= new ReplayMismatchError(message);
-    this.causality.stop();
-    for (const waiter of this.endWaiters.splice(0)) waiter.reject(this.mismatch);
-    for (const waiters of this.resultWaiters.values()) {
-      for (const waiter of waiters) waiter.reject(this.mismatch);
-    }
-    this.resultWaiters.clear();
-    return this.mismatch;
-  }
-};
-var AllocationProtocolError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "AllocationProtocolError";
-  }
-};
-var AllocationRunner = class {
-  allocation;
-  functionRef;
-  definition;
-  applicationDefinition;
-  stateStreams = /* @__PURE__ */ new Set();
-  stateStreamFlows = /* @__PURE__ */ new Map();
-  eventReadStreams = /* @__PURE__ */ new Set();
-  outputBlobRequests = /* @__PURE__ */ new Map();
-  stateOperationRequests = /* @__PURE__ */ new Map();
-  executionBatches = [];
-  executionBatchWaiters = [];
-  liveBacklog = [];
-  liveWaiters = [];
-  controller = new AbortController();
-  currentRead;
-  replay;
-  protocolError;
-  durableCallEmissionTail = Promise.resolve();
-  durableWatcherEmissionTail = Promise.resolve();
-  lastEventClock = 0;
-  previousDurableId;
-  livePump;
-  completion;
-  started = false;
-  terminalBatchQueued = false;
-  terminalBatchObserved = false;
-  terminalBatchObservedWaiters = [];
-  finished = false;
-  state = { outputBlobRequests: [], requestStateOperations: [] };
-  startedAt = Date.now();
-  constructor(allocation, functionRef, definition, applicationDefinition = definition) {
-    this.allocation = allocation;
-    this.functionRef = functionRef;
-    this.definition = definition;
-    this.applicationDefinition = applicationDefinition;
-    this.previousDurableId = String(allocation.functionCallId);
-    this.updateStateHash();
-    this.log("debug", "allocation runner created", {
-      replay_mode: allocation.replayMode,
-      input_count: allocation.inputs?.args?.length ?? 0,
-      input_blob_count: allocation.inputs?.argBlobs?.length ?? 0
-    });
-  }
-  start() {
-    if (this.started) {
-      this.log("warn", "duplicate allocation runner start ignored");
-      return;
-    }
-    this.started = true;
-    this.log("info", "allocation runner scheduled");
-    this.completion = this.run().catch((error) => {
-      this.log("error", "allocation runner promise rejected", {}, error);
-      this.queueTerminalBatch({
-        outcomeCode: "ALLOCATION_OUTCOME_CODE_FAILURE",
-        failureReason: "ALLOCATION_FAILURE_REASON_INTERNAL_ERROR"
-      });
-      this.finish();
-    });
-  }
-  waitForCompletion() {
-    return this.completion ?? Promise.resolve();
-  }
-  async waitForTerminalBatchObserved(timeoutMs) {
-    if (this.terminalBatchObserved) return true;
-    return new Promise((resolve) => {
-      let settled = false;
-      const observed = () => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        resolve(true);
-      };
-      const timer = setTimeout(() => {
-        if (settled) return;
-        settled = true;
-        const index = this.terminalBatchObservedWaiters.indexOf(observed);
-        if (index >= 0) this.terminalBatchObservedWaiters.splice(index, 1);
-        resolve(false);
-      }, Math.max(timeoutMs, 0));
-      this.terminalBatchObservedWaiters.push(observed);
-      if (this.terminalBatchObserved) observed();
-    });
-  }
-  cancel(reason = new FunctionError("Allocation was cancelled")) {
-    if (this.controller.signal.aborted) return;
-    this.log("info", "allocation cancellation requested", {
-      reason: reason instanceof Error ? reason.message : String(reason)
-    });
-    this.abortExecution(reason);
-  }
-  abortExecution(reason) {
-    if (!this.controller.signal.aborted) this.controller.abort(reason);
-    const rejection = this.controller.signal.reason ?? reason;
-    const outputBlobRequestCount = this.outputBlobRequests.size;
-    const stateOperationRequestCount = this.stateOperationRequests.size;
-    const liveWaiterCount = this.liveWaiters.length;
-    const liveBacklogCount = this.liveBacklog.length;
-    const hadCurrentRead = this.currentRead != null;
-    for (const request of this.outputBlobRequests.values()) request.reject(rejection);
-    for (const request of this.stateOperationRequests.values()) request.reject(rejection);
-    for (const waiter of this.liveWaiters.splice(0)) waiter.result.reject(rejection);
-    this.currentRead?.response.reject(rejection);
-    this.outputBlobRequests.clear();
-    this.stateOperationRequests.clear();
-    this.liveBacklog.splice(0);
-    this.currentRead = void 0;
-    this.state.outputBlobRequests = [];
-    this.state.requestStateOperations = [];
-    this.log("debug", "pending allocation protocol work settled", {
-      output_blob_requests: outputBlobRequestCount,
-      state_operation_requests: stateOperationRequestCount,
-      durable_event_waiters: liveWaiterCount,
-      durable_event_backlog_entries: liveBacklogCount,
-      event_log_read: hadCurrentRead
-    });
-  }
-  invoke(definition, args) {
-    this.log("debug", "durable function invocation requested", {
-      target_function: definition.name,
-      argument_count: args.length
-    });
-    const result = this.runChild(definition, args, 0);
-    return this.replay?.wrapDurableResult(result) ?? result;
-  }
-  runFuture(future) {
-    this.log("debug", "durable future execution requested", {
-      target_function: future.definition.name,
-      argument_count: future.args.length,
-      delay_seconds: future.delaySeconds
-    });
-    const result = this.runChild(future.definition, future.args, future.delaySeconds);
-    return this.replay?.wrapDurableResult(result) ?? result;
-  }
-  wrapFutureWait(promise) {
-    return this.replay?.wrapDurableResult(promise) ?? promise;
-  }
-  trackMixedPromiseRace(promise, producers) {
-    this.replay?.trackMixedPromiseRace(promise, producers);
-  }
-  trackPromiseSettlement(promise, onSettled) {
-    return this.replay?.trackPromiseSettlement(promise, onSettled) ?? false;
-  }
-  trackDurablePromiseConsumption(promise) {
-    this.replay?.trackDurablePromiseConsumption(promise);
-  }
-  runPromiseAggregateConstruction(callback) {
-    return this.replay?.runPromiseAggregateConstruction(callback) ?? callback();
-  }
-  reduce(definition, items, initial, hasInitial) {
-    const result = this.runReduce(definition, items, initial, hasInitial);
-    return this.replay?.wrapDurableResult(result) ?? result;
-  }
-  async runReduce(definition, items, initial, hasInitial) {
-    let reduceItems = items;
-    let reduceInitial = initial;
-    if (!hasInitial) {
-      if (items.length === 0) {
-        throw new SDKUsageError("reduce of empty iterable with no initial value");
-      }
-      [reduceInitial, ...reduceItems] = items;
-    }
-    if (reduceItems.length === 0) return reduceInitial;
-    const callTurn = this.reserveEmissionTurn("call");
-    const watcherTurn = this.reserveEmissionTurn("watcher");
-    const ids = reduceItems.map(() => this.nextDurableId(definition, "ReduceStep"));
-    const id = ids[ids.length - 1];
-    const startedAt = Date.now();
-    this.log("info", "durable reduce starting", {
-      durable_id: id,
-      target_function: definition.name,
-      collection_size: reduceItems.length,
-      plan_count: Math.ceil(reduceItems.length / MAX_REDUCE_CALLS_PER_PLAN)
-    });
-    const replayCallIds = ids.filter(
-      (_id, index) => (index + 1) % MAX_REDUCE_CALLS_PER_PLAN === 0 || index === ids.length - 1
-    );
-    for (const replayCallId of replayCallIds) this.replay?.expectCall(replayCallId);
-    this.replay?.expectWatcher(id);
-    try {
-      try {
-        await this.createReduceChain(ids, definition, reduceItems, reduceInitial, callTurn);
-      } catch (error) {
-        for (const replayCallId of replayCallIds) this.replay?.abandonCall(replayCallId);
-        this.replay?.abandonWatcher(id);
-        throw error;
-      }
-      await this.createWatcher(id, watcherTurn);
-    } finally {
-      callTurn.release();
-      watcherTurn.release();
-    }
-    const replayedResult = this.replay == null ? void 0 : await this.replay.takeResult(id);
-    const result = replayedResult ?? await this.waitForLiveEvent(
-      (entry) => entry.functionCallWatcherResult?.functionCallId === id
-    ).then((entry) => entry.functionCallWatcherResult);
-    let resolved;
-    try {
-      resolved = await this.resolveWatcherResult(result);
-    } finally {
-      if (replayedResult != null) this.replay?.completeResultResolution();
-    }
-    this.log("info", "durable reduce completed", {
-      durable_id: id,
-      target_function: definition.name,
-      collection_size: reduceItems.length,
-      duration_ms: Date.now() - startedAt
-    });
-    return resolved;
-  }
-  nextDurableId(definition, operation = "FunctionCall") {
-    const id = durableHash([
-      String(this.allocation.functionCallId),
-      this.previousDurableId,
-      operation,
-      definition.name
-    ]);
-    this.previousDurableId = id;
-    return id;
-  }
-  async runChild(definition, args, delaySeconds) {
-    const callTurn = this.reserveEmissionTurn("call");
-    const watcherTurn = this.reserveEmissionTurn("watcher");
-    const id = this.nextDurableId(definition);
-    const startedAt = Date.now();
-    const maxRetries = definition.options.retries?.maxRetries ?? this.applicationDefinition.application?.retries.maxRetries ?? 0;
-    this.log("info", "durable function call starting", {
-      durable_id: id,
-      target_function: definition.name,
-      argument_count: args.length,
-      delay_seconds: delaySeconds,
-      max_retries: maxRetries
-    });
-    this.replay?.expectCall(id);
-    this.replay?.expectWatcher(id);
-    try {
-      try {
-        await this.createChildCall(id, definition, args, delaySeconds, callTurn);
-      } catch (error) {
-        this.replay?.abandonCall(id);
-        this.replay?.abandonWatcher(id);
-        throw error;
-      }
-      await this.createWatcher(id, watcherTurn);
-    } finally {
-      callTurn.release();
-      watcherTurn.release();
-    }
-    this.log("debug", "waiting for terminal durable function result", {
-      durable_id: id,
-      target_function: definition.name,
-      max_retries: maxRetries,
-      replay_result_available: this.replay?.hasAvailableResult(id) ?? false
-    });
-    const replayedResult = this.replay == null ? void 0 : await this.replay.takeResult(id);
-    const result = replayedResult ?? await this.waitForLiveEvent(
-      (entry) => entry.functionCallWatcherResult?.functionCallId === id
-    ).then((entry) => entry.functionCallWatcherResult);
-    let resolved;
-    try {
-      resolved = await this.resolveWatcherResult(result);
-    } finally {
-      if (replayedResult != null) this.replay?.completeResultResolution();
-    }
-    this.log("info", "durable function call completed", {
-      durable_id: id,
-      target_function: definition.name,
-      max_retries: maxRetries,
-      duration_ms: Date.now() - startedAt
-    });
-    return resolved;
-  }
-  async createChildCall(id, definition, args, delaySeconds, turn) {
-    try {
-      let turnAcquired = false;
-      if (this.replay != null) {
-        await turn.wait;
-        turnAcquired = true;
-      }
-      const replayed = await this.replay?.takeOrdered("call", id);
-      if (replayed != null) {
-        this.log("debug", "replaying durable function creation", { durable_id: id });
-        const error2 = statusError(replayed.status, "Failed to start function call");
-        if (error2 != null) throw error2;
-        return;
-      }
-      const prepared = [];
-      let offset = 0;
-      for (const arg of args) {
-        const item = prepareSerializedObject(arg, offset);
-        prepared.push(item);
-        offset += item.bytes.byteLength;
-      }
-      let argsBlob;
-      if (prepared.length > 0) {
-        this.log("debug", "requesting durable function arguments blob", {
-          durable_id: id,
-          argument_count: args.length,
-          serialized_bytes: offset
-        });
-        try {
-          argsBlob = await this.requestOutputBlob(offset);
-          argsBlob = await this.uploadBlob(
-            argsBlob,
-            joinPrepared(prepared),
-            "durable function arguments",
-            { durable_id: id }
-          );
-        } catch (error2) {
-          if (this.controller.signal.aborted) throw this.controller.signal.reason;
-          throw this.latchProtocolError(
-            `Failed to materialize durable function arguments for '${id}'`,
-            error2
-          );
-        }
-      }
-      const metadata = Buffer.from(JSON.stringify({
-        format: "tensorlake.typescript.function-call.v1",
-        id,
-        functionName: definition.name,
-        argumentCount: args.length
-      }), "utf8");
-      const updates = {
-        updates: [{ functionCall: {
-          id,
-          target: {
-            namespace: this.functionRef.namespace,
-            applicationName: this.functionRef.applicationName,
-            applicationVersion: this.functionRef.applicationVersion,
-            functionName: definition.name
-          },
-          args: prepared.map((item) => ({ value: item.object })),
-          callMetadata: metadata
-        } }],
-        rootFunctionCallId: id
-      };
-      if (delaySeconds > 0) updates.startAt = protocolTimestamp(new Date(Date.now() + delaySeconds * 1e3));
-      if (!turnAcquired) await turn.wait;
-      this.log("debug", "queueing durable function creation event", {
-        durable_id: id,
-        target_function: definition.name,
-        delay_seconds: delaySeconds
-      });
-      this.addBatch([{ createFunctionCall: { updates, argsBlob } }]);
-      this.log("debug", "waiting for durable function creation acknowledgement", { durable_id: id });
-      const createdPromise = this.waitForLiveEvent((entry) => entry.functionCallCreated?.functionCallId === id);
-      turn.release();
-      const created = await createdPromise;
-      const error = statusError(created.functionCallCreated?.status, "Failed to start function call");
-      if (error != null) throw error;
-    } finally {
-      turn.release();
-    }
-  }
-  async createReduceChain(ids, definition, items, initial, turn) {
-    try {
-      let turnAcquired = false;
-      if (this.replay != null) {
-        await turn.wait;
-        turnAcquired = true;
-      }
-      const livePlans = [];
-      const liveRoots = [];
-      for (let start = 0; start < items.length; start += MAX_REDUCE_CALLS_PER_PLAN) {
-        const end = Math.min(items.length, start + MAX_REDUCE_CALLS_PER_PLAN);
-        const rootId = ids[end - 1];
-        const replayed = await this.replay?.takeOrdered("call", rootId);
-        if (replayed != null) {
-          this.log("debug", "replaying durable reduce plan creation", {
-            durable_id: rootId,
-            reduce_step_start: start,
-            reduce_step_end: end
-          });
-          const error = statusError(replayed.status, "Failed to start reduce operation");
-          if (error != null) throw error;
-          continue;
-        }
-        const prepared = [];
-        let offset = 0;
-        if (start === 0) {
-          const value = prepareSerializedObject(initial, offset);
-          prepared.push(value);
-          offset += value.bytes.byteLength;
-        }
-        for (let index = start; index < end; index += 1) {
-          const value = prepareSerializedObject(items[index], offset);
-          prepared.push(value);
-          offset += value.bytes.byteLength;
-        }
-        let argsBlob;
-        try {
-          const requested = await this.requestOutputBlob(offset);
-          argsBlob = await this.uploadBlob(
-            requested,
-            joinPrepared(prepared),
-            "durable reduce arguments",
-            { durable_id: rootId, reduce_step_start: start, reduce_step_end: end }
-          );
-        } catch (error) {
-          if (this.controller.signal.aborted) throw this.controller.signal.reason;
-          throw this.latchProtocolError(
-            `Failed to materialize durable reduce arguments for '${rootId}'`,
-            error
-          );
-        }
-        const itemOffset = start === 0 ? 1 : 0;
-        const updates = [];
-        for (let index = start; index < end; index += 1) {
-          const id = ids[index];
-          const accumulator = index === 0 ? { value: prepared[0].object } : { functionCallId: ids[index - 1] };
-          const item = prepared[itemOffset + index - start];
-          const metadata = Buffer.from(JSON.stringify({
-            format: "tensorlake.typescript.function-call.v1",
-            id,
-            functionName: definition.name,
-            argumentCount: 2,
-            operation: "reduce",
-            reduceRootId: ids[ids.length - 1],
-            reduceStep: index,
-            reduceStepCount: items.length
-          }), "utf8");
-          updates.push({ functionCall: {
-            id,
-            target: {
-              namespace: this.functionRef.namespace,
-              applicationName: this.functionRef.applicationName,
-              applicationVersion: this.functionRef.applicationVersion,
-              functionName: definition.name
-            },
-            args: [accumulator, { value: item.object }],
-            callMetadata: metadata
-          } });
-        }
-        livePlans.push({
-          createFunctionCall: {
-            updates: { updates, rootFunctionCallId: rootId },
-            argsBlob
-          }
-        });
-        liveRoots.push(rootId);
-      }
-      if (livePlans.length === 0) return;
-      if (!turnAcquired) await turn.wait;
-      this.log("debug", "queueing durable reduce function-call chains", {
-        durable_id: ids[ids.length - 1],
-        target_function: definition.name,
-        reduce_step_count: items.length,
-        plan_count: livePlans.length
-      });
-      this.addBatch(livePlans);
-      const creationWaiters = liveRoots.map((rootId) => {
-        const predicate = (entry) => entry.functionCallCreated?.functionCallId === rootId;
-        return {
-          predicate,
-          promise: this.waitForLiveEvent(predicate)
-        };
-      });
-      const createdPromises = creationWaiters.map(async ({ promise }) => {
-        const created = await promise;
-        const error = statusError(
-          created.functionCallCreated?.status,
-          "Failed to start reduce operation"
-        );
-        if (error != null) throw error;
-      });
-      turn.release();
-      try {
-        await Promise.all(createdPromises);
-      } catch (error) {
-        for (const { predicate } of creationWaiters) {
-          const index = this.liveWaiters.findIndex(
-            (waiter) => waiter.predicate === predicate
-          );
-          if (index >= 0) this.liveWaiters.splice(index, 1)[0].result.reject(error);
-        }
-        throw error;
-      }
-    } finally {
-      turn.release();
-    }
-  }
-  async createWatcher(id, turn) {
-    try {
-      await turn.wait;
-      const replayed = await this.replay?.takeOrdered("watcher", id);
-      if (replayed != null) {
-        this.log("debug", "replaying durable function watcher creation", { durable_id: id });
-        const error2 = statusError(replayed.status, "Failed to create function call watcher");
-        if (error2 != null) throw error2;
-        return;
-      }
-      this.log("debug", "queueing durable function watcher event", { durable_id: id });
-      this.addBatch([{ createFunctionCallWatcher: { functionCallId: id } }]);
-      this.log("debug", "waiting for durable function watcher acknowledgement", { durable_id: id });
-      const createdPromise = this.waitForLiveEvent(
-        (entry) => entry.functionCallWatcherCreated?.functionCallId === id
-      );
-      turn.release();
-      const created = await createdPromise;
-      const error = statusError(created.functionCallWatcherCreated?.status, "Failed to create function call watcher");
-      if (error != null) throw error;
-    } finally {
-      turn.release();
-    }
-  }
-  async resolveWatcherResult(event) {
-    this.log("debug", "resolving durable function watcher result", {
-      durable_id: event.functionCallId,
-      watcher_status: event.watcherStatus,
-      outcome_code: event.outcomeCode,
-      has_value_output: event.valueOutput != null,
-      has_request_error_output: event.requestErrorOutput != null
-    });
-    if (WATCHER_TIMED_OUT.has(event.watcherStatus)) throw new TimeoutError();
-    if (OUTCOME_SUCCESS.has(event.outcomeCode)) {
-      try {
-        const downloaded = await this.downloadSerializedObject(
-          event.valueOutput,
-          event.valueBlob,
-          "durable function result",
-          { durable_id: event.functionCallId }
-        );
-        return deserializeValueFromProtocol(downloaded);
-      } catch (error) {
-        if (this.controller.signal.aborted) throw this.controller.signal.reason;
-        throw this.latchProtocolError(
-          `Invalid successful function call watcher payload for '${String(event.functionCallId)}'`,
-          error
-        );
-      }
-    }
-    if (OUTCOME_FAILURE.has(event.outcomeCode)) {
-      if (event.requestErrorOutput != null) {
-        let message;
-        try {
-          const downloaded = await this.downloadSerializedObject(
-            event.requestErrorOutput,
-            event.requestErrorBlob,
-            "durable function request error",
-            { durable_id: event.functionCallId }
-          );
-          message = new TextDecoder("utf-8", { fatal: true }).decode(downloaded.data);
-        } catch (error) {
-          if (this.controller.signal.aborted) throw this.controller.signal.reason;
-          throw this.latchProtocolError(
-            `Invalid request-error function call watcher payload for '${String(event.functionCallId)}'`,
-            error
-          );
-        }
-        throw new RequestError(message);
-      }
-      throw new FunctionError("Function call failed");
-    }
-    throw this.latchProtocolError(
-      `Unexpected function call watcher outcome '${String(event.outcomeCode)}'`
-    );
-  }
-  latchProtocolError(message, cause) {
-    const protocolError = this.protocolError ?? (message instanceof AllocationProtocolError ? message : new AllocationProtocolError(
-      message,
-      cause === void 0 ? void 0 : { cause }
-    ));
-    this.protocolError = protocolError;
-    this.abortExecution(protocolError);
-    return protocolError;
-  }
-  async startTailCall(tailCall) {
-    const callTurn = this.reserveEmissionTurn("call");
-    const id = this.nextDurableId(tailCall.definition);
-    this.log("info", "tail call starting", {
-      durable_id: id,
-      target_function: tailCall.definition.name,
-      argument_count: tailCall.args.length
-    });
-    this.replay?.expectCall(id);
-    try {
-      await this.createChildCall(id, tailCall.definition, tailCall.args, 0, callTurn);
-    } catch (error) {
-      this.replay?.abandonCall(id);
-      throw error;
-    }
-    return id;
-  }
-  reserveEmissionTurn(kind) {
-    const previous = kind === "call" ? this.durableCallEmissionTail : this.durableWatcherEmissionTail;
-    let signalRelease;
-    const released = new Promise((resolve) => {
-      signalRelease = resolve;
-    });
-    const tail = previous.then(() => released);
-    if (kind === "call") this.durableCallEmissionTail = tail;
-    else this.durableWatcherEmissionTail = tail;
-    let didRelease = false;
-    return {
-      wait: previous,
-      release: () => {
-        if (didRelease) return;
-        didRelease = true;
-        signalRelease();
-      }
-    };
-  }
-  async run() {
-    let handlerArgs;
-    this.log("info", "allocation execution started", {
-      replay_mode: this.allocation.replayMode,
-      function: this.functionRef.functionName
-    });
-    this.emitLifecycleEvent("allocations_started", "Starting allocations");
-    try {
-      const inputs = this.allocation.inputs ?? {};
-      const objects = inputs.args ?? [];
-      const blobs = inputs.argBlobs ?? [];
-      this.log("debug", "allocation inputs validated", {
-        object_count: objects.length,
-        blob_count: blobs.length,
-        function_call_metadata_bytes: inputs.functionCallMetadata?.length ?? 0
-      });
-      if (objects.length !== blobs.length) throw new Error("Function argument and BLOB counts differ");
-      const values = await Promise.all(objects.map(
-        (object, index) => this.downloadSerializedObject(
-          object,
-          blobs[index],
-          "function input",
-          { input_index: index }
-        )
-      ));
-      this.log("info", "all function inputs downloaded", {
-        input_count: values.length,
-        total_data_bytes: values.reduce((total, value) => total + value.data.byteLength, 0)
-      });
-      const metadata = Buffer.from(inputs.functionCallMetadata ?? []);
-      if (metadata.byteLength === 0) {
-        this.log("debug", "deserializing application invocation input", {
-          content_type: values[0]?.contentType
-        });
-        if (values.length !== 1) throw new Error("Application calls require exactly one input payload");
-        try {
-          const parsed = await deserializeApplicationArguments(this.definition, values[0]);
-          handlerArgs = parsed.args;
-        } catch (error) {
-          this.log("error", "application invocation input deserialization failed", {}, error);
-          await this.finishUserError(error);
-          return;
-        }
-        this.log("debug", "application invocation input deserialized", {
-          handler_argument_count: handlerArgs.length
-        });
-      } else {
-        this.log("debug", "deserializing internal function invocation inputs", {
-          metadata_bytes: metadata.byteLength
-        });
-        const call = JSON.parse(metadata.toString("utf8"));
-        if (call.format !== "tensorlake.typescript.function-call.v1") {
-          throw new Error("Function call metadata was produced by a different SDK language");
-        }
-        if (call.argumentCount !== values.length) throw new Error("Function call metadata argument count differs");
-        try {
-          handlerArgs = values.map(deserializeValueFromProtocol);
-        } catch (error) {
-          this.log("error", "internal function argument deserialization failed", {}, error);
-          await this.finishUserError(error);
-          return;
-        }
-        this.log("debug", "internal function invocation inputs deserialized", {
-          handler_argument_count: handlerArgs.length,
-          metadata_function: call.functionName
-        });
-      }
-      if (REPLAY_STRICT.has(this.allocation.replayMode)) {
-        this.log("info", "strict replay history loading");
-        await this.loadReplayHistory();
-      } else {
-        this.log("debug", "strict replay disabled");
-      }
-      const requestContext = this.createRequestContext();
-      let result;
-      const handlerStartedAt = Date.now();
-      this.log("info", "user function handler starting", {
-        handler_argument_count: handlerArgs.length
-      });
-      try {
-        const execute = () => executeHandlerResult(this.definition, handlerArgs);
-        result = await runWithRequestContext(
-          requestContext,
-          () => runWithFunctionRuntime(this, () => waitWithAbortSignal(
-            this.replay?.runCausalHandler(execute) ?? execute(),
-            this.controller.signal
-          ))
-        );
-      } catch (error) {
-        if (error instanceof ReplayMismatchError || error instanceof AllocationProtocolError) {
-          throw error;
-        }
-        this.replay?.assertNoMismatch();
-        this.log("error", "user function handler failed", {
-          duration_ms: Date.now() - handlerStartedAt
-        }, error);
-        await this.finishUserError(error);
-        return;
-      }
-      this.log("info", "user function handler completed", {
-        duration_ms: Date.now() - handlerStartedAt,
-        result_kind: isTailCall(result) ? "tail_call" : "value",
-        result_type: result == null ? String(result) : typeof result
-      });
-      if (this.protocolError != null) throw this.protocolError;
-      this.replay?.assertNoMismatch();
-      if (isTailCall(result)) {
-        const id = await this.startTailCall(result);
-        this.replay?.assertConsumed();
-        this.controller.signal.throwIfAborted();
-        this.log("info", "queueing successful tail-call allocation finish", { tail_call_durable_id: id });
-        this.queueTerminalBatch({
-          outcomeCode: "ALLOCATION_OUTCOME_CODE_SUCCESS",
-          tailCallDurableId: id
-        });
-      } else {
-        this.replay?.assertConsumed();
-        let prepared;
-        try {
-          prepared = prepareSerializedObject(result, 0, String(this.allocation.functionCallId));
-        } catch (error) {
-          this.log("error", "function output serialization failed", {}, error);
-          await this.finishUserError(error);
-          return;
-        }
-        this.log("debug", "function output serialized", {
-          output_bytes: prepared.bytes.byteLength,
-          output_encoding: prepared.object.manifest?.encoding,
-          output_content_type: prepared.object.manifest?.contentType
-        });
-        let outputBlob = await this.requestOutputBlob(prepared.bytes.byteLength);
-        outputBlob = await this.uploadBlob(outputBlob, prepared.bytes, "function output");
-        this.controller.signal.throwIfAborted();
-        this.log("info", "queueing successful value allocation finish", {
-          output_blob_id: outputBlob.id,
-          output_bytes: prepared.bytes.byteLength
-        });
-        this.queueTerminalBatch({
-          outcomeCode: "ALLOCATION_OUTCOME_CODE_SUCCESS",
-          value: prepared.object,
-          uploadedFunctionOutputsBlob: outputBlob
-        });
-      }
-    } catch (error) {
-      const replayMismatch = error instanceof ReplayMismatchError;
-      const protocolFailure = error instanceof AllocationProtocolError || this.protocolError != null;
-      const cancelled = this.controller.signal.aborted && !protocolFailure;
-      this.log(
-        cancelled ? "info" : "error",
-        cancelled ? "allocation stopped after cancellation" : replayMismatch ? "durable replay mismatch" : "allocation internal failure",
-        {},
-        error
-      );
-      this.queueTerminalBatch({
-        outcomeCode: "ALLOCATION_OUTCOME_CODE_FAILURE",
-        failureReason: replayMismatch ? "ALLOCATION_FAILURE_REASON_REPLAY_EVENT_HISTORY_MISMATCH" : protocolFailure ? "ALLOCATION_FAILURE_REASON_INTERNAL_ERROR" : cancelled ? "ALLOCATION_FAILURE_REASON_FUNCTION_ERROR" : "ALLOCATION_FAILURE_REASON_INTERNAL_ERROR"
-      });
-    } finally {
-      this.log("info", "allocation execution stopping", {
-        duration_ms: Date.now() - this.startedAt,
-        pending_output_blob_requests: this.outputBlobRequests.size,
-        pending_state_operations: this.stateOperationRequests.size,
-        pending_event_waiters: this.liveWaiters.length
-      });
-      this.emitLifecycleEvent("allocations_finished", "Allocations completed");
-      this.finish();
-      this.replay?.dispose();
-    }
-  }
-  async finishUserError(error) {
-    const rendered = error instanceof Error ? error.message : String(error);
-    this.runWithoutReplayOwnership(() => {
-      printCloudEvent({
-        level: "error",
-        event: "function_call_failed",
-        message: rendered,
-        namespace: this.functionRef.namespace,
-        application: this.functionRef.applicationName,
-        application_version: this.functionRef.applicationVersion,
-        function: this.functionRef.functionName,
-        request_id: this.allocation.requestId,
-        function_call_id: this.allocation.functionCallId,
-        allocation_id: this.allocation.allocationId,
-        error: error instanceof Error ? error.stack?.split("\n") ?? [rendered] : [rendered]
-      });
-    });
-    if (isRequestError(error)) {
-      const output = prepareTextObject(error.message);
-      const requestErrorBlob = this.allocation.inputs?.requestErrorBlob;
-      if (requestErrorBlob == null) throw new Error("Allocation has no request error BLOB");
-      const uploaded = await this.uploadBlob(requestErrorBlob, output.bytes, "request error output");
-      this.log("info", "queueing request-error allocation finish", {
-        request_error_bytes: output.bytes.byteLength,
-        request_error_blob_id: uploaded.id
-      });
-      this.queueTerminalBatch({
-        outcomeCode: "ALLOCATION_OUTCOME_CODE_FAILURE",
-        failureReason: "ALLOCATION_FAILURE_REASON_REQUEST_ERROR",
-        requestErrorOutput: output.object,
-        uploadedRequestErrorBlob: uploaded
-      });
-      return;
-    }
-    this.log("info", "queueing function-error allocation finish", {}, error);
-    this.queueTerminalBatch({
-      outcomeCode: "ALLOCATION_OUTCOME_CODE_FAILURE",
-      failureReason: "ALLOCATION_FAILURE_REASON_FUNCTION_ERROR"
-    });
-  }
-  createRequestContext() {
-    return {
-      requestId: String(this.allocation.requestId),
-      headers: new Headers2(
-        (this.allocation.inputs?.requestContext?.headers ?? []).map(
-          (header) => [
-            String(header.name ?? ""),
-            String(header.value ?? "")
-          ]
-        )
-      ),
-      signal: this.controller.signal,
-      state: {
-        get: async (key, defaultValue) => {
-          validateRequestStateKey(key);
-          const operationId = randomUUID3();
-          this.log("debug", "request state read starting", {
-            state_key: key,
-            operation_id: operationId,
-            has_default: defaultValue !== void 0
-          });
-          const result = await this.requestStateOperation({ operationId, stateKey: key, prepareRead: {} });
-          if (result.status?.code === NOT_FOUND) {
-            this.log("debug", "request state key not found", { state_key: key, operation_id: operationId });
-            return defaultValue;
-          }
-          const error = statusError(result.status, `Failed to read request state '${key}'`);
-          if (error != null) throw error;
-          const data = await this.downloadBlob(result.prepareRead?.blob, "request state value", {
-            state_key: key,
-            operation_id: operationId
-          });
-          const value = deserializeJSON(data);
-          this.log("debug", "request state read completed", {
-            state_key: key,
-            operation_id: operationId,
-            value_bytes: data.byteLength
-          });
-          return value;
-        },
-        set: async (key, value) => {
-          validateRequestStateKey(key);
-          const serialized = serializeRequestStateValue(value);
-          const prepareOperationId = randomUUID3();
-          this.log("debug", "request state write preparation starting", {
-            state_key: key,
-            operation_id: prepareOperationId,
-            value_bytes: serialized.byteLength
-          });
-          const prepared = await this.requestStateOperation({
-            operationId: prepareOperationId,
-            stateKey: key,
-            prepareWrite: { size: serialized.byteLength }
-          });
-          const error = statusError(prepared.status, `Failed to prepare request state '${key}'`);
-          if (error != null) throw error;
-          const blob = await this.uploadBlob(prepared.prepareWrite?.blob, serialized, "request state value", {
-            state_key: key,
-            operation_id: prepareOperationId
-          });
-          const commitOperationId = randomUUID3();
-          this.log("debug", "request state write commit starting", {
-            state_key: key,
-            operation_id: commitOperationId,
-            blob_id: blob.id
-          });
-          const committed = await this.requestStateOperation({
-            operationId: commitOperationId,
-            stateKey: key,
-            commitWrite: { blob }
-          });
-          const commitError = statusError(committed.status, `Failed to commit request state '${key}'`);
-          if (commitError != null) throw commitError;
-          this.log("debug", "request state write completed", {
-            state_key: key,
-            operation_id: commitOperationId,
-            value_bytes: serialized.byteLength
-          });
-        }
-      },
-      metrics: {
-        counter: async (name, value = 1) => {
-          validateCounterMetric(name, value);
-          this.emitUserEvent("ai.tensorlake.metric.counter.inc", {
-            counter_name: name,
-            counter_inc: value
-          });
-        },
-        timer: async (name, value) => {
-          validateTimerMetric(name, value);
-          this.emitUserEvent("ai.tensorlake.metric.timer", {
-            timer_name: name,
-            timer_value: value
-          });
-        }
-      },
-      progress: {
-        update: async (current, total, options) => {
-          validateProgressUpdate(current, total, options);
-          this.log("debug", "request progress update", {
-            current,
-            total,
-            has_custom_message: options?.message != null,
-            attribute_count: Object.keys(options?.attributes ?? {}).length
-          });
-          this.state.progress = { current, total };
-          this.publishState();
-          const message = options?.message ?? `${this.functionRef.functionName}: executing step ${current} of ${total}`;
-          this.runWithoutReplayOwnership(() => {
-            printCloudEvent({ RequestProgressUpdated: {
-              request_id: this.allocation.requestId,
-              function_name: this.functionRef.functionName,
-              function_run_id: this.allocation.functionCallId,
-              allocation_id: this.allocation.allocationId,
-              message,
-              step: current,
-              total,
-              attributes: options?.attributes,
-              created_at: (/* @__PURE__ */ new Date()).toISOString()
-            } }, {
-              type: "ai.tensorlake.progress_update",
-              source: "/tensorlake/applications/progress",
-              message
-            });
-          });
-        }
-      }
-    };
-  }
-  emitUserEvent(type, data) {
-    this.log("debug", "user metric event emitted", {
-      event_type: type,
-      metric_name: data.counter_name ?? data.timer_name
-    });
-    this.runWithoutReplayOwnership(() => {
-      printCloudEvent({
-        request_id: this.allocation.requestId,
-        function_name: this.functionRef.functionName,
-        function_run_id: this.allocation.functionCallId,
-        allocation_id: this.allocation.allocationId,
-        ...data
-      }, { type, source: "/tensorlake/applications/metrics" });
-    });
-  }
-  emitLifecycleEvent(event, message) {
-    this.runWithoutReplayOwnership(() => {
-      printCloudEvent({
-        event,
-        message,
-        allocations: [{
-          namespace: this.functionRef.namespace,
-          application: this.functionRef.applicationName,
-          application_version: this.functionRef.applicationVersion,
-          function: this.functionRef.functionName,
-          request_id: this.allocation.requestId,
-          function_call_id: this.allocation.functionCallId,
-          allocation_id: this.allocation.allocationId
-        }]
-      });
-    });
-  }
-  async loadReplayHistory() {
-    const entries = [];
-    let afterClock = 0;
-    let page = 0;
-    while (true) {
-      page += 1;
-      this.log("debug", "requesting replay history page", { page, after_clock: afterClock });
-      const requestedAfterClock = afterClock;
-      const response = await this.readEvents(afterClock);
-      entries.push(...response.entries ?? []);
-      this.log("debug", "replay history page received", {
-        page,
-        entry_count: response.entries?.length ?? 0,
-        last_clock: response.lastClock,
-        has_more: response.hasMore
-      });
-      const responseClock = validatedEventLogClock(
-        response,
-        requestedAfterClock,
-        (message) => new ReplayMismatchError(message)
-      );
-      afterClock = responseClock;
-      if (!response.hasMore) break;
-    }
-    this.lastEventClock = afterClock;
-    this.replay = new ReplayHistory(entries);
-    this.log("info", "strict replay history loaded", {
-      page_count: page,
-      entry_count: entries.length,
-      last_clock: afterClock
-    });
-  }
-  waitForLiveEvent(predicate) {
-    if (this.controller.signal.aborted) {
-      return Promise.reject(this.controller.signal.reason);
-    }
-    const index = this.liveBacklog.findIndex(predicate);
-    if (index >= 0) {
-      this.log("debug", "durable event satisfied from backlog", {
-        backlog_size: this.liveBacklog.length,
-        pending_waiters: this.liveWaiters.length
-      });
-      return Promise.resolve(this.liveBacklog.splice(index, 1)[0]);
-    }
-    const result = deferred();
-    this.liveWaiters.push({ predicate, result });
-    this.log("debug", "waiting for durable event", {
-      backlog_size: this.liveBacklog.length,
-      pending_waiters: this.liveWaiters.length
-    });
-    this.ensureLivePump();
-    return result.promise;
-  }
-  ensureLivePump() {
-    if (this.livePump != null) {
-      this.log("debug", "durable event live pump already running");
-      return;
-    }
-    this.log("info", "durable event live pump starting", { after_clock: this.lastEventClock });
-    const pump = (async () => {
-      while (!this.finished && this.liveWaiters.length > 0) {
-        const requestedAfterClock = this.lastEventClock;
-        const response = await this.readEvents(this.lastEventClock);
-        this.log("debug", "durable event log page received", {
-          requested_after_clock: requestedAfterClock,
-          entry_count: response.entries?.length ?? 0,
-          last_clock: response.lastClock,
-          has_more: response.hasMore
-        });
-        const responseClock = validatedEventLogClock(
-          response,
-          requestedAfterClock,
-          (message) => new AllocationProtocolError(message)
-        );
-        this.lastEventClock = responseClock;
-        for (const entry of response.entries ?? []) this.dispatchLiveEvent(entry);
-      }
-    })();
-    this.livePump = pump;
-    void pump.then(() => {
-      if (this.livePump !== pump) return;
-      this.livePump = void 0;
-      this.log("debug", "durable event live pump stopped", {
-        finished: this.finished,
-        pending_waiters: this.liveWaiters.length,
-        after_clock: this.lastEventClock
-      });
-      if (!this.finished && this.liveWaiters.length > 0) this.ensureLivePump();
-    }, (error) => {
-      if (this.livePump === pump) this.livePump = void 0;
-      if (!this.finished && !this.controller.signal.aborted) {
-        const protocolError = error instanceof AllocationProtocolError ? error : new AllocationProtocolError(
-          error instanceof Error ? error.message : String(error),
-          { cause: error }
-        );
-        this.latchProtocolError(protocolError);
-        this.log("error", "durable event live pump failed", {
-          pending_waiters: this.liveWaiters.length
-        }, protocolError);
-      }
-    });
-  }
-  dispatchLiveEvent(entry) {
-    const index = this.liveWaiters.findIndex((waiter) => waiter.predicate(entry));
-    const eventKind = Object.keys(entry).find((key) => key !== "clock") ?? "unknown";
-    if (index < 0) {
-      this.liveBacklog.push(entry);
-      this.log("debug", "durable event added to backlog", {
-        event_kind: eventKind,
-        event_clock: entry.clock,
-        backlog_size: this.liveBacklog.length
-      });
-    } else {
-      this.liveWaiters.splice(index, 1)[0].result.resolve(entry);
-      this.log("debug", "durable event delivered to waiter", {
-        event_kind: eventKind,
-        event_clock: entry.clock,
-        pending_waiters: this.liveWaiters.length
-      });
-    }
-  }
-  readEvents(afterClock) {
-    if (this.currentRead != null) {
-      throw new AllocationProtocolError("Allocation event log already has a pending read");
-    }
-    const response = deferred();
-    const request = {
-      allocationId: this.allocation.allocationId,
-      afterClock,
-      maxEntries: 100
-    };
-    this.currentRead = { request, response };
-    this.log("debug", "event log read requested", {
-      after_clock: afterClock,
-      max_entries: request.maxEntries,
-      connected_streams: this.eventReadStreams.size
-    });
-    for (const stream of [...this.eventReadStreams]) {
-      try {
-        stream.write(request);
-      } catch (error) {
-        this.dropEventReadStream(stream, "write_failed", error);
-      }
-    }
-    return response.promise;
-  }
-  watchEventLogReads(stream) {
-    this.eventReadStreams.add(stream);
-    this.log("info", "event log read stream connected", {
-      connected_streams: this.eventReadStreams.size,
-      has_pending_read: this.currentRead != null
-    });
-    try {
-      stream.on("cancelled", () => this.dropEventReadStream(stream, "cancelled"));
-      stream.on("close", () => this.dropEventReadStream(stream, "closed"));
-      if (this.currentRead != null) {
-        this.log("debug", "sending pending event log read to new stream", {
-          after_clock: this.currentRead.request.afterClock,
-          max_entries: this.currentRead.request.maxEntries
-        });
-        stream.write(this.currentRead.request);
-      }
-      if (this.finished && this.currentRead == null) stream.end();
-    } catch (error) {
-      this.dropEventReadStream(stream, "setup_failed", error);
-      throw error;
-    }
-  }
-  deliverEventLogResponse(response) {
-    if (this.currentRead == null) {
-      this.log("warn", "unexpected event log response ignored", {
-        entry_count: response.entries?.length ?? 0,
-        last_clock: response.lastClock
-      });
-      return;
-    }
-    const pending = this.currentRead;
-    this.currentRead = void 0;
-    this.log("debug", "event log response delivered", {
-      requested_after_clock: pending.request.afterClock,
-      entry_count: response.entries?.length ?? 0,
-      last_clock: response.lastClock,
-      has_more: response.hasMore
-    });
-    pending.response.resolve(response);
-  }
-  requestOutputBlob(size) {
-    if (this.controller.signal.aborted) {
-      return Promise.reject(this.controller.signal.reason);
-    }
-    const id = randomUUID3();
-    const request = deferred();
-    this.outputBlobRequests.set(id, request);
-    this.state.outputBlobRequests.push({ id, size });
-    this.log("debug", "output blob requested", {
-      blob_id: id,
-      requested_bytes: size,
-      pending_output_blob_requests: this.outputBlobRequests.size
-    });
-    this.publishState();
-    return request.promise.then((output) => {
-      this.log("debug", "output blob response received", {
-        blob_id: id,
-        status_code: output.status?.code,
-        chunk_count: output.blob?.chunks?.length ?? 0
-      });
-      const error = statusError(output.status, "Failed to create output BLOB");
-      if (error != null) throw error;
-      return output.blob;
-    });
-  }
-  requestStateOperation(operation) {
-    if (this.controller.signal.aborted) {
-      return Promise.reject(this.controller.signal.reason);
-    }
-    const request = deferred();
-    this.stateOperationRequests.set(operation.operationId, request);
-    this.state.requestStateOperations.push(operation);
-    this.log("debug", "request state operation queued", {
-      operation_id: operation.operationId,
-      state_key: operation.stateKey,
-      operation_kind: this.stateOperationKind(operation),
-      requested_bytes: operation.prepareWrite?.size,
-      pending_state_operations: this.stateOperationRequests.size
-    });
-    this.publishState();
-    return request.promise;
-  }
-  deliverUpdate(update) {
-    if (update.outputBlob != null) {
-      let id = String(update.outputBlob.blob?.id ?? "");
-      let matchedByOrder = false;
-      if (!id) {
-        id = String(this.state.outputBlobRequests[0]?.id ?? "");
-        matchedByOrder = id !== "";
-      }
-      const request = this.outputBlobRequests.get(id);
-      if (request == null) {
-        this.log("warn", "unmatched output blob update ignored", {
-          blob_id: id || void 0,
-          status_code: update.outputBlob.status?.code,
-          pending_output_blob_requests: this.outputBlobRequests.size
-        });
-        return;
-      }
-      this.outputBlobRequests.delete(id);
-      this.state.outputBlobRequests = this.state.outputBlobRequests.filter((item) => item.id !== id);
-      this.log("debug", "output blob update matched", {
-        blob_id: id,
-        status_code: update.outputBlob.status?.code,
-        chunk_count: update.outputBlob.blob?.chunks?.length ?? 0,
-        matched_by_order: matchedByOrder,
-        pending_output_blob_requests: this.outputBlobRequests.size
-      });
-      request.resolve(update.outputBlob);
-      this.publishState();
-      return;
-    }
-    const result = update.requestStateOperationResult;
-    if (result != null) {
-      if (typeof result.operationId !== "string" || result.operationId.length === 0) {
-        throw this.latchProtocolError(
-          "Allocation received a request state operation result without an operation ID"
-        );
-      }
-      const id = result.operationId;
-      const request = this.stateOperationRequests.get(id);
-      if (request == null) {
-        this.log("warn", "unmatched request state operation result ignored", {
-          operation_id: id,
-          status_code: result.status?.code,
-          pending_state_operations: this.stateOperationRequests.size
-        });
-        return;
-      }
-      const operation = this.state.requestStateOperations.find((item) => item.operationId === id);
-      this.stateOperationRequests.delete(id);
-      this.state.requestStateOperations = this.state.requestStateOperations.filter(
-        (item) => item.operationId !== id
-      );
-      this.log("debug", "request state operation result matched", {
-        operation_id: id,
-        state_key: operation?.stateKey,
-        operation_kind: this.stateOperationKind(operation),
-        status_code: result.status?.code,
-        pending_state_operations: this.stateOperationRequests.size
-      });
-      request.resolve(result);
-      this.publishState();
-      return;
-    }
-    this.log("warn", "allocation update contained no recognized payload");
-  }
-  watchState(stream) {
-    this.stateStreams.add(stream);
-    this.stateStreamFlows.set(stream, { backpressured: false });
-    this.log("info", "allocation state stream connected", {
-      connected_streams: this.stateStreams.size,
-      state_hash: this.state.sha256Hash,
-      pending_output_blob_requests: this.outputBlobRequests.size,
-      pending_state_operations: this.stateOperationRequests.size
-    });
-    try {
-      stream.on("cancelled", () => this.dropStateStream(stream, "cancelled"));
-      stream.on("close", () => this.dropStateStream(stream, "closed"));
-      stream.on("drain", () => this.drainStateStream(stream));
-      this.writeStateSnapshot(stream, this.snapshotState());
-      if (this.finished) stream.end();
-    } catch (error) {
-      this.dropStateStream(stream, "setup_failed", error);
-      throw error;
-    }
-  }
-  updateStateHash() {
-    const content = JSON.stringify({
-      progress: this.state.progress,
-      outputBlobRequests: this.state.outputBlobRequests,
-      requestStateOperations: this.state.requestStateOperations
-    });
-    this.state.sha256Hash = createHash3("sha256").update(content).digest("hex");
-  }
-  snapshotState() {
-    return nativeStructuredClone(this.state);
-  }
-  publishState() {
-    this.updateStateHash();
-    this.log("debug", "allocation state published", {
-      state_hash: this.state.sha256Hash,
-      connected_streams: this.stateStreams.size,
-      pending_output_blob_requests: this.outputBlobRequests.size,
-      pending_state_operations: this.stateOperationRequests.size,
-      progress_current: this.state.progress?.current,
-      progress_total: this.state.progress?.total
-    });
-    for (const stream of [...this.stateStreams]) {
-      this.writeStateSnapshot(stream, this.snapshotState());
-    }
-  }
-  writeStateSnapshot(stream, snapshot) {
-    const flow = this.stateStreamFlows.get(stream);
-    if (flow == null) return;
-    if (flow.backpressured) {
-      flow.pending = snapshot;
-      return;
-    }
-    try {
-      flow.backpressured = !stream.write(snapshot);
-    } catch (error) {
-      this.dropStateStream(stream, "write_failed", error);
-    }
-  }
-  drainStateStream(stream) {
-    const flow = this.stateStreamFlows.get(stream);
-    if (flow == null) return;
-    flow.backpressured = false;
-    const pending = flow.pending;
-    flow.pending = void 0;
-    if (pending != null) this.writeStateSnapshot(stream, pending);
-  }
-  addBatch(events) {
-    if (this.terminalBatchQueued && events.every((event) => event.finishAllocation == null)) {
-      this.log("error", "execution event rejected after terminal batch", {
-        event_count: events.length,
-        event_kinds: events.map((event) => Object.keys(event)[0] ?? "unknown")
-      });
-      return;
-    }
-    this.executionBatches.push(events);
-    this.log("debug", "execution log batch queued", {
-      event_count: events.length,
-      event_kinds: events.map((event) => Object.keys(event)[0] ?? "unknown"),
-      queued_batches: this.executionBatches.length,
-      waiting_consumers: this.executionBatchWaiters.length
-    });
-    for (const waiter of this.executionBatchWaiters.splice(0)) {
-      this.markTerminalBatchObserved(events);
-      waiter(events);
-    }
-  }
-  queueTerminalBatch(finishAllocation) {
-    if (this.terminalBatchQueued) {
-      this.log("error", "duplicate terminal allocation batch rejected", {
-        outcome_code: finishAllocation.outcomeCode,
-        failure_reason: finishAllocation.failureReason
-      });
-      return;
-    }
-    this.terminalBatchQueued = true;
-    this.addBatch([{ finishAllocation }]);
-  }
-  async getExecutionBatch() {
-    if (this.executionBatches.length > 0) {
-      this.log("debug", "returning queued execution log batch", {
-        event_count: this.executionBatches[0].length,
-        queued_batches: this.executionBatches.length
-      });
-      const events = this.executionBatches[0];
-      this.markTerminalBatchObserved(events);
-      return events;
-    }
-    if (this.finished) {
-      this.log("debug", "returning empty execution log batch for finished allocation");
-      return [];
-    }
-    this.log("debug", "execution log batch consumer waiting", {
-      waiting_consumers: this.executionBatchWaiters.length + 1
-    });
-    return new Promise((resolve) => this.executionBatchWaiters.push(resolve));
-  }
-  advanceExecutionBatch() {
-    const advanced = this.executionBatches.shift();
-    this.log("debug", "execution log batch advanced", {
-      advanced_event_count: advanced?.length ?? 0,
-      queued_batches: this.executionBatches.length
-    });
-  }
-  markTerminalBatchObserved(events) {
-    if (this.terminalBatchObserved || !events.some((event) => event.finishAllocation != null)) {
-      return;
-    }
-    this.terminalBatchObserved = true;
-    this.log("debug", "terminal execution log batch observed by consumer");
-    for (const waiter of this.terminalBatchObservedWaiters.splice(0)) waiter();
-  }
-  get isFinished() {
-    return this.finished;
-  }
-  finish() {
-    if (this.finished) {
-      this.log("debug", "allocation finish ignored because runner is already finished");
-      return;
-    }
-    this.finished = true;
-    this.abortExecution(new FunctionError("Allocation finished"));
-    this.log("info", "allocation runner finished", {
-      duration_ms: Date.now() - this.startedAt,
-      queued_execution_batches: this.executionBatches.length,
-      state_streams: this.stateStreams.size,
-      event_log_streams: this.eventReadStreams.size
-    });
-    for (const stream of [...this.stateStreams]) {
-      try {
-        stream.end();
-      } catch (error) {
-        this.dropStateStream(stream, "end_failed", error);
-      }
-    }
-    for (const stream of [...this.eventReadStreams]) {
-      try {
-        stream.end();
-      } catch (error) {
-        this.dropEventReadStream(stream, "end_failed", error);
-      }
-    }
-    for (const waiter of this.executionBatchWaiters.splice(0)) waiter([]);
-  }
-  dropStateStream(stream, reason, error) {
-    if (!this.stateStreams.delete(stream)) return;
-    this.stateStreamFlows.delete(stream);
-    this.log("info", "allocation state stream disconnected", {
-      reason,
-      connected_streams: this.stateStreams.size
-    }, error);
-  }
-  dropEventReadStream(stream, reason, error) {
-    if (!this.eventReadStreams.delete(stream)) return;
-    this.log("info", "event log read stream disconnected", {
-      reason,
-      connected_streams: this.eventReadStreams.size,
-      has_pending_read: this.currentRead != null
-    }, error);
-  }
-  stateOperationKind(operation) {
-    if (operation?.prepareRead != null) return "prepare_read";
-    if (operation?.prepareWrite != null) return "prepare_write";
-    if (operation?.commitWrite != null) return "commit_write";
-    return "unknown";
-  }
-  blobLogFields(blob) {
-    const chunks = blob?.chunks ?? [];
-    return {
-      blob_id: blob?.id,
-      chunk_count: chunks.length,
-      declared_bytes: chunks.reduce((total, chunk) => total + (chunk.size ?? 0), 0)
-    };
-  }
-  async downloadBlob(blob, purpose, fields = {}) {
-    if (blob == null) throw new Error(`Missing BLOB for ${purpose}`);
-    const startedAt = Date.now();
-    this.log("debug", "blob download starting", {
-      purpose,
-      ...fields,
-      ...this.blobLogFields(blob)
-    });
-    try {
-      const data = await downloadBlob(
-        blob,
-        (message, details) => this.log("debug", `blob ${message}`, {
-          purpose,
-          ...fields,
-          ...details
-        }),
-        this.controller.signal
-      );
-      this.log("debug", "blob download completed", {
-        purpose,
-        ...fields,
-        ...this.blobLogFields(blob),
-        downloaded_bytes: data.byteLength,
-        duration_ms: Date.now() - startedAt
-      });
-      return data;
-    } catch (error) {
-      this.log("error", "blob download failed", {
-        purpose,
-        ...fields,
-        ...this.blobLogFields(blob),
-        duration_ms: Date.now() - startedAt
-      }, error);
-      throw error;
-    }
-  }
-  async downloadSerializedObject(object, blob, purpose, fields = {}) {
-    if (object == null) throw new Error(`Missing serialized object for ${purpose}`);
-    if (blob == null) throw new Error(`Missing BLOB for ${purpose}`);
-    const startedAt = Date.now();
-    this.log("debug", "serialized object download starting", {
-      purpose,
-      ...fields,
-      ...this.blobLogFields(blob),
-      object_offset: object.offset ?? 0,
-      object_bytes: object.manifest?.size,
-      metadata_bytes: object.manifest?.metadataSize,
-      content_type: object.manifest?.contentType,
-      encoding: object.manifest?.encoding
-    });
-    try {
-      const value = await downloadSerializedObject(
-        object,
-        blob,
-        (message, details) => this.log(
-          "debug",
-          `blob ${message}`,
-          { purpose, ...fields, ...details }
-        ),
-        this.controller.signal
-      );
-      this.log("debug", "serialized object download completed", {
-        purpose,
-        ...fields,
-        ...this.blobLogFields(blob),
-        object_bytes: value.data.byteLength + value.metadata.byteLength,
-        data_bytes: value.data.byteLength,
-        metadata_bytes: value.metadata.byteLength,
-        duration_ms: Date.now() - startedAt
-      });
-      return value;
-    } catch (error) {
-      this.log("error", "serialized object download failed", {
-        purpose,
-        ...fields,
-        ...this.blobLogFields(blob),
-        duration_ms: Date.now() - startedAt
-      }, error);
-      throw error;
-    }
-  }
-  async uploadBlob(blob, data, purpose, fields = {}) {
-    if (blob == null) throw new Error(`Missing BLOB for ${purpose}`);
-    const startedAt = Date.now();
-    this.log("debug", "blob upload starting", {
-      purpose,
-      ...fields,
-      ...this.blobLogFields(blob),
-      upload_bytes: data.byteLength
-    });
-    try {
-      const uploaded = await uploadBlob(
-        blob,
-        data,
-        (message, details) => this.log("debug", `blob ${message}`, {
-          purpose,
-          ...fields,
-          ...details
-        }),
-        this.controller.signal
-      );
-      this.log("debug", "blob upload completed", {
-        purpose,
-        ...fields,
-        ...this.blobLogFields(uploaded),
-        upload_bytes: data.byteLength,
-        duration_ms: Date.now() - startedAt
-      });
-      return uploaded;
-    } catch (error) {
-      this.log("error", "blob upload failed", {
-        purpose,
-        ...fields,
-        ...this.blobLogFields(blob),
-        upload_bytes: data.byteLength,
-        duration_ms: Date.now() - startedAt
-      }, error);
-      throw error;
-    }
-  }
-  log(level, message, fields = {}, error) {
-    this.runWithoutReplayOwnership(() => {
-      writeStructuredOutput("stderr", () => {
-        const rendered = error instanceof Error ? error.stack?.split("\n") ?? [`${error.name}: ${error.message}`] : error == null ? void 0 : [String(error)];
-        return {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          level,
-          component: "typescript_function_executor_allocation",
-          message,
-          allocation_id: this.allocation.allocationId,
-          request_id: this.allocation.requestId,
-          function_call_id: this.allocation.functionCallId,
-          namespace: this.functionRef.namespace,
-          application: this.functionRef.applicationName,
-          application_version: this.functionRef.applicationVersion,
-          function: this.functionRef.functionName,
-          elapsed_ms: Date.now() - this.startedAt,
-          ...fields,
-          ...rendered == null ? {} : { error: rendered }
-        };
-      });
-    });
-  }
-  runWithoutReplayOwnership(callback) {
-    return this.replay?.runWithoutCausalOwnership(callback) ?? callback();
-  }
-};
-
-// src/function-executor/service.ts
-var SHUTDOWN_TERMINAL_DRAIN_TIMEOUT_MS = 1e3;
-var nativeImport = compileFunction(
-  "return import(specifier)",
-  ["specifier"],
-  { importModuleDynamically: vmConstants.USE_MAIN_CONTEXT_DEFAULT_LOADER }
-);
-function rpcError(code, details) {
-  return Object.assign(new Error(details), { code, details, metadata: new grpc.Metadata() });
-}
-function requireSafeSize(value, field) {
-  if (!Number.isSafeInteger(value) || Number(value) < 0) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, `${field} must be a non-negative safe integer`);
-  }
-  return Number(value);
-}
-function validateSerializedObjectManifest(manifest, field) {
-  if (manifest == null) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, `${field}.manifest is required`);
-  }
-  if (manifest.encoding == null) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, `${field}.manifest.encoding is required`);
-  }
-  if (manifest.encodingVersion == null) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, `${field}.manifest.encoding_version is required`);
-  }
-  requireSafeSize(manifest.encodingVersion, `${field}.manifest.encoding_version`);
-  requireSafeSize(manifest.size, `${field}.manifest.size`);
-  if (manifest.metadataSize == null) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, `${field}.manifest.metadata_size is required`);
-  }
-  const metadataSize = requireSafeSize(manifest.metadataSize, `${field}.manifest.metadata_size`);
-  if (metadataSize > Number(manifest.size)) {
-    throw rpcError(
-      grpc.status.INVALID_ARGUMENT,
-      `${field}.manifest.metadata_size cannot exceed size`
-    );
-  }
-  if (typeof manifest.sha256Hash !== "string" || manifest.sha256Hash.length === 0) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, `${field}.manifest.sha256_hash is required`);
-  }
-}
-function validateBlob(blob, field) {
-  if (blob == null) throw rpcError(grpc.status.INVALID_ARGUMENT, `${field} is required`);
-  if (!Array.isArray(blob.chunks)) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, `${field}.chunks must be an array`);
-  }
-  blob.chunks.forEach((chunk, index) => {
-    if (chunk == null || typeof chunk.uri !== "string" || chunk.uri.length === 0) {
-      throw rpcError(grpc.status.INVALID_ARGUMENT, `${field}.chunks[${index}].uri is required`);
-    }
-    requireSafeSize(chunk.size, `${field}.chunks[${index}].size`);
-  });
-}
-function validateNewAllocation(allocation) {
-  if (allocation == null) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, "CreateAllocationRequest.allocation is required");
-  }
-  for (const [field, value] of [
-    ["request_id", allocation.requestId],
-    ["function_call_id", allocation.functionCallId],
-    ["allocation_id", allocation.allocationId]
-  ]) {
-    if (typeof value !== "string" || value.length === 0) {
-      throw rpcError(grpc.status.INVALID_ARGUMENT, `Allocation.${field} is required`);
-    }
-  }
-  const inputs = allocation.inputs;
-  if (inputs == null) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, "Allocation.inputs is required");
-  }
-  if (!Array.isArray(inputs.args) || !Array.isArray(inputs.argBlobs)) {
-    throw rpcError(grpc.status.INVALID_ARGUMENT, "Allocation input args and arg_blobs must be arrays");
-  }
-  if (inputs.args.length !== inputs.argBlobs.length) {
-    throw rpcError(
-      grpc.status.INVALID_ARGUMENT,
-      `Mismatched function arguments and argument blobs lengths, ${inputs.args.length} != ${inputs.argBlobs.length}`
-    );
-  }
-  inputs.args.forEach((argument, index) => {
-    if (argument == null) {
-      throw rpcError(grpc.status.INVALID_ARGUMENT, `Allocation.inputs.args[${index}] is required`);
-    }
-    requireSafeSize(argument.offset, `Allocation.inputs.args[${index}].offset`);
-    validateSerializedObjectManifest(argument.manifest, `Allocation.inputs.args[${index}]`);
-    validateBlob(inputs.argBlobs[index], `Allocation.inputs.arg_blobs[${index}]`);
-  });
-  validateBlob(inputs.requestErrorBlob, "Allocation.inputs.request_error_blob");
-}
-function safeArchivePath(root, archivePath) {
-  const output = path.resolve(root, archivePath);
-  if (output !== root && !output.startsWith(`${root}${path.sep}`)) {
-    throw new Error(`Application archive contains unsafe path '${archivePath}'`);
-  }
-  return output;
-}
-async function unpackApplicationCode(data) {
-  const root = await mkdtemp(path.join(os.tmpdir(), "tensorlake-typescript-app-"));
-  try {
-    const files = unzipSync(data);
-    for (const [name, content] of Object.entries(files)) {
-      const destination = safeArchivePath(root, name);
-      await mkdir(path.dirname(destination), { recursive: true });
-      await writeFile(destination, content, { mode: 384 });
-    }
-    const manifest = JSON.parse(
-      await readFile(path.join(root, ".tensorlake_code_manifest.json"), "utf8")
-    );
-    return { root, manifest };
-  } catch (error) {
-    await rm(root, { recursive: true, force: true });
-    throw error;
-  }
-}
-var FunctionExecutorService = class {
-  allocations = /* @__PURE__ */ new Map();
-  functionRef;
-  definition;
-  applicationDefinition;
-  initialization;
-  stopping = false;
-  shutdownPromise;
-  implementation = {
-    initialize: this.initialize.bind(this),
-    listAllocations: this.listAllocations.bind(this),
-    createAllocation: this.createAllocation.bind(this),
-    deleteAllocation: this.deleteAllocation.bind(this),
-    watchAllocationState: this.watchAllocationState.bind(this),
-    sendAllocationUpdate: this.sendAllocationUpdate.bind(this),
-    getAllocationExecutionLogBatch: this.getAllocationExecutionLogBatch.bind(this),
-    advanceAllocationExecutionLogBatch: this.advanceAllocationExecutionLogBatch.bind(this),
-    watchAllocationEventLogReads: this.watchAllocationEventLogReads.bind(this),
-    sendAllocationEventLogReadResponse: this.sendAllocationEventLogReadResponse.bind(this),
-    checkHealth: this.checkHealth.bind(this),
-    getInfo: this.getInfo.bind(this)
-  };
-  shutdown(reason = new Error("Function executor is shutting down")) {
-    if (this.shutdownPromise != null) return this.shutdownPromise;
-    this.stopping = true;
-    const shutdown = (async () => {
-      this.log("info", "function executor service shutdown requested", {
-        allocation_count: this.allocations.size
-      });
-      const allocations = [...this.allocations.values()];
-      for (const allocation of allocations) allocation.cancel(reason);
-      await Promise.all(allocations.map((allocation) => allocation.waitForCompletion()));
-      const terminalObservations = await Promise.all(
-        allocations.map(
-          (allocation) => allocation.waitForTerminalBatchObserved(SHUTDOWN_TERMINAL_DRAIN_TIMEOUT_MS)
-        )
-      );
-      const unobservedCount = terminalObservations.filter((observed) => !observed).length;
-      if (unobservedCount > 0) {
-        this.log(
-          "warn",
-          "shutdown terminal execution batches were not observed before drain deadline",
-          { unobserved_allocation_count: unobservedCount }
-        );
-      }
-      this.log("info", "function executor service shutdown completed", {
-        allocation_count: allocations.length
-      });
-    })();
-    this.shutdownPromise = shutdown;
-    return shutdown;
-  }
-  initialize(call, callback) {
-    if (this.stopping) {
-      callback(rpcError(grpc.status.UNAVAILABLE, "Function Executor is shutting down"));
-      return;
-    }
-    const startedAt = Date.now();
-    this.log("info", "initialize RPC received", {
-      ...this.functionLogFields(call.request.function),
-      application_code_bytes: call.request.applicationCode?.data?.length
-    });
-    this.emitInitializationEvent(call.request.function, "function_executor_initialization_started", "Initializing function executor");
-    void this.initializeAsync(call.request).then(
-      () => {
-        this.log("info", "initialize RPC completed", {
-          ...this.functionLogFields(call.request.function),
-          duration_ms: Date.now() - startedAt,
-          outcome: "success"
-        });
-        this.emitInitializationEvent(call.request.function, "function_executor_initialization_finished", "Function executor initialization completed");
-        callback(null, { outcomeCode: "INITIALIZATION_OUTCOME_CODE_SUCCESS" });
-      },
-      (error) => {
-        const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-        this.log("error", "initialize RPC failed", {
-          ...this.functionLogFields(call.request.function),
-          duration_ms: Date.now() - startedAt,
-          outcome: "failure"
-        }, error);
-        this.emitInitializationEvent(
-          call.request.function,
-          "function_executor_initialization_failed",
-          "Function executor initialization failed",
-          error
-        );
-        callback(null, {
-          outcomeCode: "INITIALIZATION_OUTCOME_CODE_FAILURE",
-          failureReason: "INITIALIZATION_FAILURE_REASON_FUNCTION_ERROR",
-          errorMessage: message
-        });
-      }
-    );
-  }
-  emitInitializationEvent(functionRef, event, message, error) {
-    const rendered = error instanceof Error ? error.stack?.split("\n") : error == null ? void 0 : [String(error)];
-    printCloudEvent({
-      ...error == null ? {} : { level: "error" },
-      event,
-      message,
-      namespace: functionRef?.namespace,
-      application: functionRef?.applicationName,
-      application_version: functionRef?.applicationVersion,
-      function: functionRef?.functionName,
-      ...rendered == null ? {} : { error: rendered }
-    });
-  }
-  async initializeAsync(request) {
-    if (this.definition != null) throw new Error("Function Executor is already initialized");
-    if (this.initialization != null) throw new Error("Function Executor initialization is already in progress");
-    const initialization = this.initializeAttempt(request);
-    this.initialization = initialization;
-    try {
-      await initialization;
-    } finally {
-      if (this.initialization === initialization) this.initialization = void 0;
-    }
-  }
-  async initializeAttempt(request) {
-    if (request.function == null) throw new Error("InitializeRequest.function is required");
-    for (const [field, value] of [
-      ["namespace", request.function.namespace],
-      ["application_name", request.function.applicationName],
-      ["function_name", request.function.functionName],
-      ["application_version", request.function.applicationVersion]
-    ]) {
-      if (typeof value !== "string" || value.length === 0) {
-        throw new Error(`InitializeRequest.function.${field} is required`);
-      }
-    }
-    if (request.applicationCode == null) throw new Error("InitializeRequest.application_code is required");
-    if (request.applicationCode.manifest == null) throw new Error("InitializeRequest.application_code.manifest is required");
-    if (request.applicationCode.data == null) throw new Error("InitializeRequest.application_code.data is required");
-    const codeManifest = request.applicationCode.manifest;
-    if (codeManifest.encoding == null) throw new Error("InitializeRequest.application_code.manifest.encoding is required");
-    if (codeManifest.encodingVersion == null) throw new Error("InitializeRequest.application_code.manifest.encoding_version is required");
-    if (codeManifest.size == null) throw new Error("InitializeRequest.application_code.manifest.size is required");
-    if (codeManifest.sha256Hash == null) throw new Error("InitializeRequest.application_code.manifest.sha256_hash is required");
-    if (!(/* @__PURE__ */ new Set(["SERIALIZED_OBJECT_ENCODING_BINARY_ZIP", 4])).has(codeManifest.encoding)) {
-      throw new Error(
-        `Invalid application code encoding: ${String(codeManifest.encoding)}. Expected: BINARY_ZIP`
-      );
-    }
-    const declaredSize = requireSafeSize(
-      codeManifest.size,
-      "InitializeRequest.application_code.manifest.size"
-    );
-    const metadataSize = codeManifest.metadataSize == null ? 0 : requireSafeSize(
-      codeManifest.metadataSize,
-      "InitializeRequest.application_code.manifest.metadata_size"
-    );
-    if (metadataSize > declaredSize) {
-      throw new Error(
-        "InitializeRequest.application_code.manifest.metadata_size cannot exceed size"
-      );
-    }
-    const archive = new Uint8Array(request.applicationCode.data);
-    this.log("debug", "unpacking application code", {
-      ...this.functionLogFields(request.function),
-      application_code_bytes: archive.byteLength
-    });
-    const unpackStartedAt = Date.now();
-    const { root, manifest } = await unpackApplicationCode(archive);
-    let registrySnapshot;
-    try {
-      this.log("debug", "application code unpacked", {
-        ...this.functionLogFields(request.function),
-        duration_ms: Date.now() - unpackStartedAt,
-        manifest_format_version: manifest.format_version,
-        manifest_runtime: manifest.runtime,
-        manifest_function_count: Object.keys(manifest.functions ?? {}).length
-      });
-      if (manifest.format_version !== 2 || manifest.runtime !== "typescript") {
-        throw new Error("Application code is not a Tensorlake TypeScript bundle");
-      }
-      const nodeMajor = Number(process.versions.node.split(".")[0]);
-      if ((manifest.minimum_node_major ?? 24) > nodeMajor) {
-        throw new Error(`Application requires Node ${manifest.minimum_node_major} or newer; executor has ${nodeMajor}`);
-      }
-      const moduleName = manifest.module;
-      if (!moduleName) throw new Error("Application code manifest does not name a runtime module");
-      const functionName = String(request.function.functionName);
-      if (manifest.functions?.[functionName] == null) {
-        throw new Error(`Function '${functionName}' is not present in the application bundle`);
-      }
-      const modulePath = safeArchivePath(root, moduleName);
-      this.log("debug", "importing application runtime module", {
-        ...this.functionLogFields(request.function),
-        module: moduleName
-      });
-      const importStartedAt = Date.now();
-      registrySnapshot = snapshotRegistry();
-      const runtime = await nativeImport(`${pathToFileURL(modulePath).href}?executor=${Date.now()}`);
-      if (typeof runtime.__tensorlakeGetFunction !== "function") {
-        throw new Error("Application runtime does not export __tensorlakeGetFunction");
-      }
-      const definition = runtime.__tensorlakeGetFunction(functionName);
-      if (definition?.name !== functionName) {
-        throw new Error(
-          `Application runtime resolved function '${functionName}' as '${String(definition?.name)}'`
-        );
-      }
-      const applicationName = String(request.function.applicationName);
-      const applicationDefinition = runtime.__tensorlakeGetFunction(applicationName);
-      if (applicationDefinition?.name !== applicationName) {
-        throw new Error(
-          `Application runtime resolved application '${applicationName}' as '${String(applicationDefinition?.name)}'`
-        );
-      }
-      if (applicationDefinition.application == null) {
-        throw new Error(`'${applicationName}' is not a Tensorlake application`);
-      }
-      this.functionRef = request.function;
-      this.definition = definition;
-      this.applicationDefinition = applicationDefinition;
-      this.log("debug", "application function resolved", {
-        ...this.functionLogFields(request.function),
-        duration_ms: Date.now() - importStartedAt,
-        parameter_count: definition.parameters.length,
-        application_max_retries: applicationDefinition.application.retries.maxRetries
-      });
-      registrySnapshot = void 0;
-    } catch (error) {
-      if (registrySnapshot != null) restoreRegistry(registrySnapshot);
-      this.functionRef = void 0;
-      this.definition = void 0;
-      this.applicationDefinition = void 0;
-      await rm(root, { recursive: true, force: true });
-      throw error;
-    }
-  }
-  getAllocation(id) {
-    const allocation = this.allocations.get(id);
-    if (allocation == null) throw rpcError(grpc.status.NOT_FOUND, `Allocation ${id} not found`);
-    return allocation;
-  }
-  listAllocations(_call, callback) {
-    this.log("debug", "list allocations RPC received", { allocation_count: this.allocations.size });
-    callback(null, { allocations: [...this.allocations.values()].map((runner) => runner.allocation) });
-  }
-  createAllocation(call, callback) {
-    void this.createAllocationAsync(call).then(
-      () => callback(null, {}),
-      (error) => {
-        this.log(
-          "error",
-          "create allocation RPC failed",
-          this.allocationLogFields(call.request.allocation),
-          error
-        );
-        callback(error);
-      }
-    );
-  }
-  async createAllocationAsync(call) {
-    if (this.stopping) {
-      throw rpcError(grpc.status.UNAVAILABLE, "Function Executor is shutting down");
-    }
-    const initialization = this.initialization;
-    if (initialization != null) {
-      this.log("info", "create allocation RPC waiting for initialization", {
-        ...this.allocationLogFields(call.request.allocation)
-      });
-      await this.waitForInitialization(call, initialization);
-      this.log("info", "create allocation RPC resumed after initialization", {
-        ...this.allocationLogFields(call.request.allocation)
-      });
-    }
-    this.assertAllocationAdmissionActive(call);
-    if (this.stopping) {
-      throw rpcError(grpc.status.UNAVAILABLE, "Function Executor is shutting down");
-    }
-    if (this.definition == null || this.applicationDefinition == null || this.functionRef == null) {
-      throw rpcError(grpc.status.FAILED_PRECONDITION, "Function Executor is not initialized");
-    }
-    const allocation = call.request.allocation;
-    validateNewAllocation(allocation);
-    const id = String(allocation.allocationId);
-    this.log("info", "create allocation RPC received", {
-      ...this.allocationLogFields(allocation),
-      replay_mode: allocation?.replayMode,
-      input_count: allocation?.inputs?.args?.length ?? 0
-    });
-    if (this.allocations.has(id)) throw rpcError(grpc.status.ALREADY_EXISTS, `Allocation ${id} already exists`);
-    const runner = new AllocationRunner(
-      allocation,
-      this.functionRef,
-      this.definition,
-      this.applicationDefinition
-    );
-    this.allocations.set(id, runner);
-    runner.start();
-    this.log("info", "allocation runner started", this.allocationLogFields(allocation));
-  }
-  waitForInitialization(call, initialization) {
-    return new Promise((resolve, reject) => {
-      let timer;
-      let settled = false;
-      const deadline = typeof call.getDeadline === "function" ? call.getDeadline() : Infinity;
-      const deadlineMs = deadline instanceof Date ? deadline.getTime() : Number(deadline);
-      const cancellationError = () => Number.isFinite(deadlineMs) && deadlineMs <= Date.now() ? rpcError(
-        grpc.status.DEADLINE_EXCEEDED,
-        "Initialization did not finish before the allocation deadline"
-      ) : rpcError(
-        grpc.status.CANCELLED,
-        "Create allocation RPC was cancelled during initialization"
-      );
-      const onCancelled = () => finish(cancellationError());
-      const finish = (error) => {
-        if (settled) return;
-        settled = true;
-        if (timer != null) clearTimeout(timer);
-        if (typeof call.off === "function") call.off("cancelled", onCancelled);
-        if (error == null) resolve();
-        else reject(error);
-      };
-      if (call.cancelled || Number.isFinite(deadlineMs) && deadlineMs <= Date.now()) {
-        finish(cancellationError());
-        return;
-      }
-      if (typeof call.once === "function") call.once("cancelled", onCancelled);
-      if (Number.isFinite(deadlineMs)) {
-        const remainingMs = deadlineMs - Date.now();
-        if (remainingMs <= 0) {
-          finish(rpcError(grpc.status.DEADLINE_EXCEEDED, "Initialization did not finish before the allocation deadline"));
-          return;
-        }
-        timer = setTimeout(() => {
-          finish(rpcError(
-            grpc.status.DEADLINE_EXCEEDED,
-            "Initialization did not finish before the allocation deadline"
-          ));
-        }, remainingMs);
-      }
-      initialization.then(
-        () => finish(
-          call.cancelled || Number.isFinite(deadlineMs) && deadlineMs <= Date.now() ? cancellationError() : void 0
-        ),
-        () => finish(rpcError(
-          grpc.status.FAILED_PRECONDITION,
-          "Function Executor initialization failed"
-        ))
-      );
-    });
-  }
-  assertAllocationAdmissionActive(call) {
-    const deadline = typeof call.getDeadline === "function" ? call.getDeadline() : Infinity;
-    const deadlineMs = deadline instanceof Date ? deadline.getTime() : Number(deadline);
-    if (Number.isFinite(deadlineMs) && deadlineMs <= Date.now()) {
-      throw rpcError(grpc.status.DEADLINE_EXCEEDED, "Create allocation RPC deadline exceeded");
-    }
-    if (call.cancelled) {
-      throw rpcError(grpc.status.CANCELLED, "Create allocation RPC was cancelled before allocation start");
-    }
-  }
-  deleteAllocation(call, callback) {
-    try {
-      const id = String(call.request.allocationId ?? "");
-      const allocation = this.getAllocation(id);
-      this.log("debug", "delete allocation RPC received", {
-        allocation_id: id,
-        finished: allocation.isFinished
-      });
-      if (!allocation.isFinished) {
-        throw rpcError(grpc.status.FAILED_PRECONDITION, `Allocation ${id} is still running`);
-      }
-      this.allocations.delete(id);
-      this.log("info", "allocation deleted", { allocation_id: id });
-      callback(null, {});
-    } catch (error) {
-      this.log("error", "delete allocation RPC failed", { allocation_id: call.request.allocationId }, error);
-      callback(error);
-    }
-  }
-  watchAllocationState(call) {
-    try {
-      const allocationId = String(call.request.allocationId ?? "");
-      this.log("debug", "allocation state stream opening", { allocation_id: allocationId });
-      this.getAllocation(allocationId).watchState(call);
-    } catch (error) {
-      this.log("error", "allocation state stream failed to open", { allocation_id: call.request.allocationId }, error);
-      call.destroy(error);
-    }
-  }
-  sendAllocationUpdate(call, callback) {
-    try {
-      const allocationId = String(call.request.allocationId ?? "");
-      this.log("debug", "allocation update RPC received", {
-        allocation_id: allocationId,
-        update_kind: call.request.outputBlob != null ? "output_blob" : call.request.requestStateOperationResult != null ? "request_state_operation_result" : "unknown"
-      });
-      if (call.request.outputBlob == null && call.request.requestStateOperationResult == null) {
-        throw rpcError(
-          grpc.status.INVALID_ARGUMENT,
-          `Unknown update type in AllocationUpdate for allocation ${allocationId}`
-        );
-      }
-      const allocation = this.getAllocation(allocationId);
-      if (allocation.isFinished) throw rpcError(grpc.status.FAILED_PRECONDITION, "Allocation is already finished");
-      allocation.deliverUpdate(call.request);
-      callback(null, {});
-    } catch (error) {
-      this.log("error", "allocation update RPC failed", { allocation_id: call.request.allocationId }, error);
-      callback(error);
-    }
-  }
-  getAllocationExecutionLogBatch(call, callback) {
-    try {
-      const allocationId = String(call.request.allocationId ?? "");
-      this.log("debug", "execution log batch RPC waiting", { allocation_id: allocationId });
-      const allocation = this.getAllocation(allocationId);
-      void allocation.getExecutionBatch().then(
-        (events) => {
-          this.log("debug", "execution log batch RPC completed", {
-            allocation_id: allocationId,
-            event_count: events.length
-          });
-          callback(null, { events });
-        },
-        (error) => {
-          this.log("error", "execution log batch RPC failed", { allocation_id: allocationId }, error);
-          callback(error);
-        }
-      );
-    } catch (error) {
-      this.log("error", "execution log batch RPC failed", { allocation_id: call.request.allocationId }, error);
-      callback(error);
-    }
-  }
-  advanceAllocationExecutionLogBatch(call, callback) {
-    try {
-      const allocationId = String(call.request.allocationId ?? "");
-      this.log("debug", "advance execution log batch RPC received", { allocation_id: allocationId });
-      this.getAllocation(allocationId).advanceExecutionBatch();
-      callback(null, {});
-    } catch (error) {
-      this.log("error", "advance execution log batch RPC failed", { allocation_id: call.request.allocationId }, error);
-      callback(error);
-    }
-  }
-  watchAllocationEventLogReads(call) {
-    try {
-      const allocationId = String(call.request.allocationId ?? "");
-      const allocation = this.getAllocation(allocationId);
-      this.log("debug", "event log read stream opening", { allocation_id: allocationId });
-      call.sendMetadata(new grpc.Metadata());
-      this.log("debug", "event log read stream established", { allocation_id: allocationId });
-      allocation.watchEventLogReads(call);
-    } catch (error) {
-      this.log("error", "event log read stream failed to open", { allocation_id: call.request.allocationId }, error);
-      call.destroy(error);
-    }
-  }
-  sendAllocationEventLogReadResponse(call, callback) {
-    try {
-      const allocationId = String(call.request.allocationId ?? "");
-      this.log("debug", "event log read response RPC received", {
-        allocation_id: allocationId,
-        entry_count: call.request.entries?.length ?? 0,
-        last_clock: call.request.lastClock,
-        has_more: call.request.hasMore
-      });
-      this.getAllocation(allocationId).deliverEventLogResponse(call.request);
-      callback(null, {});
-    } catch (error) {
-      this.log("error", "event log read response RPC failed", { allocation_id: call.request.allocationId }, error);
-      callback(error);
-    }
-  }
-  checkHealth(_call, callback) {
-    this.log("debug", "health check RPC received", { initialized: this.definition != null });
-    if (this.definition == null) {
-      callback(rpcError(grpc.status.UNAVAILABLE, "Function Executor is not initialized"));
-    } else {
-      callback(null, { healthy: true, statusMessage: "ok" });
-    }
-  }
-  getInfo(_call, callback) {
-    this.log("debug", "executor info RPC received", { protocol_version: "0.1.3" });
-    callback(null, {
-      version: "0.1.3",
-      sdkVersion: SDK_VERSION,
-      sdkLanguage: "typescript",
-      sdkLanguageVersion: process.versions.node
-    });
-  }
-  functionLogFields(functionRef) {
-    return {
-      namespace: functionRef?.namespace,
-      application: functionRef?.applicationName,
-      application_version: functionRef?.applicationVersion,
-      function: functionRef?.functionName
-    };
-  }
-  allocationLogFields(allocation) {
-    return {
-      allocation_id: allocation?.allocationId,
-      request_id: allocation?.requestId,
-      function_call_id: allocation?.functionCallId
-    };
-  }
-  log(level, message, fields = {}, error) {
-    writeStructuredOutput("stderr", () => {
-      const rendered = error instanceof Error ? error.stack?.split("\n") ?? [`${error.name}: ${error.message}`] : error == null ? void 0 : [String(error)];
-      return {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        level,
-        component: "typescript_function_executor_service",
-        message,
-        ...fields,
-        ...rendered == null ? {} : { error: rendered }
-      };
-    });
-  }
-};
-
-// src/function-executor/main.ts
-var SHUTDOWN_GRACE_PERIOD_MS = 1e4;
-var IPV4_LOOPBACK_ADDRESS = "127.0.0.1";
-function functionExecutorBindAddress(address) {
-  if (address === "localhost") return IPV4_LOOPBACK_ADDRESS;
-  if (address.startsWith("localhost:")) {
-    return `${IPV4_LOOPBACK_ADDRESS}${address.slice("localhost".length)}`;
-  }
-  return address;
-}
-function parseArguments(argv) {
-  const result = { functionExecutorId: "" };
-  for (let index = 0; index < argv.length; index += 1) {
-    const argument = argv[index];
-    const [key, inline] = argument.split("=", 2);
-    const value = inline ?? argv[index + 1];
-    if (key === "--address") result.address = value;
-    else if (key === "--executor-id") result.executorId = value;
-    else if (key === "--function-executor-id") result.functionExecutorId = value ?? "";
-    else continue;
-    if (inline == null) index += 1;
-  }
-  return result;
-}
-function serviceDefinition() {
-  const protoRoot = functionExecutorProtoRoot();
-  const protoPath = path2.join(protoRoot, "tensorlake/function_executor/proto/function_executor.proto");
-  const packageDefinition = loadSync(protoPath, {
-    includeDirs: [path2.dirname(protoPath), protoRoot, getProtoPath()],
-    keepCase: false,
-    longs: Number,
-    enums: String,
-    defaults: false,
-    oneofs: true
-  });
-  const loaded = grpc2.loadPackageDefinition(packageDefinition);
-  return loaded.function_executor_service.FunctionExecutor.service;
-}
-function functionExecutorProtoRoot() {
-  const relativeRoots = [
-    // Standalone function-executor capsule.
-    "../../proto/",
-    // Function executor launched directly from the published SDK package.
-    "../../runtime/function-executor/package/proto/",
-    // Development checkout: both language runtimes use the repository source.
-    "../../../proto/"
-  ];
-  for (const relativeRoot of relativeRoots) {
-    const protoRoot = fileURLToPath2(new URL(relativeRoot, import.meta.url));
-    const protoPath = path2.join(protoRoot, "tensorlake/function_executor/proto/function_executor.proto");
-    if (existsSync(protoPath)) return protoRoot;
-  }
-  throw new Error("Cannot find the shared Tensorlake function-executor protobuf definition");
-}
-async function main(argv = process.argv.slice(2)) {
-  configureNativeWorker(() => new URL("../native-worker.cjs", import.meta.url));
-  const nodeMajor = Number(process.versions.node.split(".")[0]);
-  if (nodeMajor < 24) throw new Error(`Tensorlake TypeScript functions require Node 24 or newer; got ${process.versions.node}`);
-  const args = parseArguments(argv);
-  if (!args.address) throw new Error("--address argument is required");
-  if (!args.executorId) throw new Error("--executor-id argument is required");
-  const address = functionExecutorBindAddress(args.address);
-  writeStructuredOutput("stderr", () => ({
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    level: "info",
-    component: "typescript_function_executor_main",
-    message: "starting TypeScript function executor",
-    address,
-    executor_id: args.executorId,
-    fn_executor_id: args.functionExecutorId,
-    node_version: process.versions.node,
-    pid: process.pid
-  }));
-  const server = new grpc2.Server({
-    "grpc.max_receive_message_length": -1,
-    "grpc.max_send_message_length": -1,
-    "grpc.so_reuseport": 0
-  });
-  const service = new FunctionExecutorService();
-  server.addService(serviceDefinition(), service.implementation);
-  await new Promise((resolve, reject) => {
-    server.bindAsync(address, grpc2.ServerCredentials.createInsecure(), (error) => {
-      if (error != null) reject(error);
-      else resolve();
-    });
-  });
-  writeStructuredOutput("stderr", () => ({
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    level: "info",
-    component: "typescript_function_executor_main",
-    message: "started TypeScript function executor",
-    address,
-    executor_id: args.executorId,
-    fn_executor_id: args.functionExecutorId,
-    node_version: process.versions.node
-  }));
-  let stopping = false;
-  const shutdown = (signal) => {
-    if (stopping) return;
-    stopping = true;
-    writeStructuredOutput("stderr", () => ({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      level: "info",
-      component: "typescript_function_executor_main",
-      message: "stopping TypeScript function executor",
-      signal,
-      executor_id: args.executorId,
-      fn_executor_id: args.functionExecutorId,
-      pid: process.pid
-    }));
-    const forceShutdownTimer = setTimeout(() => {
-      writeStructuredOutput("stderr", () => ({
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        level: "error",
-        component: "typescript_function_executor_main",
-        message: "forcing TypeScript function executor shutdown after grace period",
-        signal,
-        executor_id: args.executorId,
-        fn_executor_id: args.functionExecutorId,
-        pid: process.pid,
-        grace_period_ms: SHUTDOWN_GRACE_PERIOD_MS
-      }));
-      server.forceShutdown();
-      process.exit(1);
-    }, SHUTDOWN_GRACE_PERIOD_MS);
-    const gracefulShutdown = service.shutdown(new Error(`Function executor received ${signal}`)).then(() => new Promise((resolve, reject) => {
-      server.tryShutdown((error) => {
-        if (error != null) reject(error);
-        else resolve();
-      });
-    }));
-    void gracefulShutdown.then(
-      () => {
-        clearTimeout(forceShutdownTimer);
-        writeStructuredOutput("stderr", () => ({
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          level: "info",
-          component: "typescript_function_executor_main",
-          message: "stopped TypeScript function executor",
-          signal,
-          executor_id: args.executorId,
-          fn_executor_id: args.functionExecutorId,
-          pid: process.pid
-        }));
-        process.exit(0);
-      },
-      (error) => {
-        clearTimeout(forceShutdownTimer);
-        writeStructuredOutput("stderr", () => ({
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          level: "error",
-          component: "typescript_function_executor_main",
-          message: "TypeScript function executor shutdown failed",
-          signal,
-          executor_id: args.executorId,
-          fn_executor_id: args.functionExecutorId,
-          pid: process.pid,
-          error: error instanceof Error ? `${error.name}: ${error.message}` : String(error)
-        }));
-        server.forceShutdown();
-        process.exit(1);
-      }
-    );
-  };
-  process.once("SIGINT", () => shutdown("SIGINT"));
-  process.once("SIGTERM", () => shutdown("SIGTERM"));
-}
-export {
-  functionExecutorBindAddress,
-  main
-};
-//# sourceMappingURL=main.js.map