symnav 0.0.0 → 1.0.0

package/dist/worker-entry.js

@@ -0,0 +1,1051 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// ../../packages/daemon/dist/state-write-errors.js
+var DaemonStateWriteError, DaemonStateWriteErrors;
+var init_state_write_errors = __esm({
+  "../../packages/daemon/dist/state-write-errors.js"() {
+    "use strict";
+    DaemonStateWriteError = class extends Error {
+      failure;
+      code;
+      path;
+      syscall;
+      constructor(failure, cause) {
+        super(cause instanceof Error ? cause.message : "Required state write failed", { cause });
+        this.failure = failure;
+        this.code = failure.osCode;
+        this.path = failure.path;
+        this.syscall = cause?.syscall;
+      }
+    };
+    DaemonStateWriteErrors = class {
+      static from(error, fallbackPath) {
+        const seen = /* @__PURE__ */ new Set();
+        let current = error;
+        while (typeof current === "object" && current !== null && !seen.has(current)) {
+          seen.add(current);
+          if (current instanceof DaemonStateWriteError)
+            return current.failure;
+          const failure = current;
+          if (failure.syscall !== void 0 && /^(mkdir|write|rename|unlink|rmdir|chmod|fsync)/u.test(failure.syscall)) {
+            const path = failure.path ?? fallbackPath;
+            if (path !== void 0)
+              return { path, ...failure.code === void 0 ? {} : { osCode: failure.code } };
+          }
+          current = "cause" in current ? current.cause : void 0;
+        }
+        return void 0;
+      }
+      static failedWrite(path, error) {
+        const failure = error;
+        const osCode = failure?.code;
+        return new DaemonStateWriteError({ path: failure?.path ?? path, ...typeof osCode === "string" ? { osCode } : {} }, error);
+      }
+      static isFailure(value) {
+        if (typeof value !== "object" || value === null || Array.isArray(value))
+          return false;
+        const failure = value;
+        const keys = Object.keys(failure);
+        return typeof failure.path === "string" && failure.path.length > 0 && keys.every((key) => key === "path" || key === "osCode") && (failure.osCode === void 0 || typeof failure.osCode === "string");
+      }
+    };
+  }
+});
+
+// ../../packages/daemon/dist/diagnostics/failure-recorder.js
+import { randomUUID } from "node:crypto";
+var DaemonFailureRecorder;
+var init_failure_recorder = __esm({
+  "../../packages/daemon/dist/diagnostics/failure-recorder.js"() {
+    "use strict";
+    init_state_write_errors();
+    DaemonFailureRecorder = class _DaemonFailureRecorder {
+      journal;
+      workspaceRoot;
+      clock;
+      stateWriteFailed;
+      constructor(journal, workspaceRoot, clock, stateWriteFailed) {
+        this.journal = journal;
+        this.workspaceRoot = workspaceRoot;
+        this.clock = clock;
+        this.stateWriteFailed = stateWriteFailed;
+      }
+      async record(kind, phase, reason, error, instanceId, requestId) {
+        try {
+          await this.journal.record({
+            schemaVersion: 1,
+            eventId: `${kind}:${kind === "fallback" ? requestId ?? randomUUID() : instanceId ?? randomUUID()}`,
+            workspaceRoot: this.workspaceRoot,
+            ...instanceId === void 0 ? {} : { instanceId },
+            ...requestId === void 0 ? {} : { requestId },
+            kind,
+            failure: _DaemonFailureRecorder.failure(this.clock.wallNowMs(), phase, reason, error)
+          });
+        } catch (writeError) {
+          const failure = DaemonStateWriteErrors.from(writeError);
+          if (failure !== void 0)
+            this.stateWriteFailed?.(failure);
+        }
+      }
+      static failure(timestamp, phase, reason, error) {
+        const osCode = this.osCode(error);
+        return {
+          phase,
+          reason: phase === "endpoint connect" && osCode === "ECONNRESET" ? "daemon-connection-reset" : reason,
+          timestamp,
+          ...osCode === void 0 ? {} : { osCode }
+        };
+      }
+      static osCode(error) {
+        const seen = /* @__PURE__ */ new Set();
+        let current = error;
+        while (typeof current === "object" && current !== null && !seen.has(current)) {
+          seen.add(current);
+          if ("code" in current && typeof current.code === "string" && /^(?:E[A-Z0-9_]{1,63}|ERR_[A-Z0-9_]{1,60})$/u.test(current.code))
+            return current.code;
+          current = "cause" in current ? current.cause : void 0;
+        }
+        return void 0;
+      }
+    };
+  }
+});
+
+// ../../packages/daemon/dist/daemon-command-name.js
+var commandNames, DAEMON_COMMAND_NAMES;
+var init_daemon_command_name = __esm({
+  "../../packages/daemon/dist/daemon-command-name.js"() {
+    "use strict";
+    commandNames = [
+      "overview",
+      "resolve",
+      "def",
+      "refs",
+      "context",
+      "graph",
+      "stats",
+      "help",
+      "version",
+      "unknown"
+    ];
+    DAEMON_COMMAND_NAMES = Object.freeze(commandNames);
+  }
+});
+
+// ../../packages/daemon/dist/daemon-policy.js
+var MEBIBYTE, DaemonPolicy, DaemonPolicyCodec;
+var init_daemon_policy = __esm({
+  "../../packages/daemon/dist/daemon-policy.js"() {
+    "use strict";
+    MEBIBYTE = 1024 * 1024;
+    DaemonPolicy = class _DaemonPolicy {
+      values;
+      constructor(values) {
+        this.values = _DaemonPolicy.freeze(values);
+        Object.freeze(this);
+      }
+      static currentSystem() {
+        const runtimeProcess = globalThis.process;
+        const constrainedBytes = runtimeProcess.constrainedMemory?.();
+        return _DaemonPolicy.fromSystemMemory({
+          totalBytes: runtimeProcess.binding("os").getTotalMem(),
+          ...constrainedBytes === void 0 ? {} : { constrainedBytes }
+        });
+      }
+      static fromSystemMemory(memory) {
+        const effectiveMemoryBytes = memory.constrainedBytes !== void 0 && memory.constrainedBytes > 0 && memory.constrainedBytes < memory.totalBytes ? memory.constrainedBytes : memory.totalBytes;
+        const effectiveMemoryMiB = Math.max(1, Math.floor(effectiveMemoryBytes / MEBIBYTE));
+        const hardProcessRssMiB = _DaemonPolicy.clamp(Math.floor(effectiveMemoryMiB / 2), 256, 8192);
+        const workerMaxOldGenerationSizeMiB = _DaemonPolicy.clamp(Math.floor(effectiveMemoryMiB / 4), 128, 4096);
+        return new _DaemonPolicy({
+          transport: {
+            singleResponseTimeoutMs: 250,
+            statusResponseTimeoutMs: 100,
+            executionAdmissionTimeoutMs: 5e3,
+            maximumJsonPayloadBytes: 8 * MEBIBYTE,
+            maximumExecutionControlPayloadBytes: 256 * 1024
+          },
+          startup: {
+            coordinationGraceMs: 15e3,
+            heartbeatIntervalMs: 100,
+            authorizationPollIntervalMs: 10,
+            observationPollIntervalMs: 20,
+            previousInstanceTerminationTimeoutMs: 5 * 6e4,
+            childFailureRetryLimit: 1
+          },
+          shutdown: {
+            idleTimeoutMs: 30 * 6e4,
+            stopTimeoutMs: 5e3,
+            forcedTerminationReserveMaximumMs: 500,
+            controllerPollIntervalMs: 20,
+            processSignalExitTimeoutMs: 500,
+            processExitPollIntervalMs: 20,
+            resourceDrainAcknowledgementGraceMs: 250,
+            resourceDrainAcknowledgementPollIntervalMs: 5
+          },
+          delivery: {
+            postAcceptanceExecutionReattachmentLimit: 1,
+            resultTransferResumeLimitPerExecutionAttempt: 1
+          },
+          output: {
+            maximumChunkRawBytes: 64 * 1024,
+            inlineRawBytes: 256 * 1024,
+            maximumResultRawBytes: 256 * MEBIBYTE,
+            maximumAggregateSpoolRawBytes: 512 * MEBIBYTE
+          },
+          resources: {
+            effectiveMemoryBytes,
+            hardProcessRssBytes: hardProcessRssMiB * MEBIBYTE,
+            softProcessRssBytes: Math.floor(hardProcessRssMiB * 0.8) * MEBIBYTE,
+            resumeProcessRssBytes: Math.floor(hardProcessRssMiB * 0.7) * MEBIBYTE,
+            workerMaxOldGenerationSizeMiB,
+            supervisionIntervalMs: 250,
+            replacementWindowMs: 10 * 6e4,
+            replacementLimit: 2,
+            workerHeapSampleIntervalMs: 25
+          },
+          diagnostics: {
+            logRotateBytes: 10 * MEBIBYTE,
+            logBackupCount: 4,
+            maximumQueuedEvents: 1024,
+            disconnectedTraceRetentionMs: 5 * 6e4,
+            maximumDisconnectedTraces: 1024
+          }
+        });
+      }
+      static clamp(value, minimum, maximum) {
+        return Math.max(minimum, Math.min(maximum, value));
+      }
+      static freeze(values) {
+        for (const section of Object.values(values))
+          Object.freeze(section);
+        return Object.freeze(values);
+      }
+    };
+    DaemonPolicyCodec = class _DaemonPolicyCodec {
+      static serialize(policy) {
+        return Object.freeze({ schemaVersion: 1, values: policy.values });
+      }
+      static parse(value) {
+        if (!_DaemonPolicyCodec.isRecord(value))
+          throw new Error("Invalid daemon policy");
+        _DaemonPolicyCodec.exactKeys(value, ["schemaVersion", "values"]);
+        if (value.schemaVersion !== 1 || !_DaemonPolicyCodec.isRecord(value.values)) {
+          throw new Error("Invalid daemon policy");
+        }
+        const values = value.values;
+        _DaemonPolicyCodec.validateValues(values);
+        return JSON.parse(JSON.stringify(values));
+      }
+      static deserialize(value) {
+        const PolicyConstructor = DaemonPolicy;
+        return new PolicyConstructor(_DaemonPolicyCodec.parse(value));
+      }
+      static validateValues(values) {
+        _DaemonPolicyCodec.exactKeys(values, [
+          "transport",
+          "startup",
+          "shutdown",
+          "delivery",
+          "output",
+          "resources",
+          "diagnostics"
+        ]);
+        const transport = _DaemonPolicyCodec.section(values, "transport", [
+          "singleResponseTimeoutMs",
+          "statusResponseTimeoutMs",
+          "executionAdmissionTimeoutMs",
+          "maximumJsonPayloadBytes",
+          "maximumExecutionControlPayloadBytes"
+        ]);
+        const startup = _DaemonPolicyCodec.section(values, "startup", [
+          "coordinationGraceMs",
+          "heartbeatIntervalMs",
+          "authorizationPollIntervalMs",
+          "observationPollIntervalMs",
+          "previousInstanceTerminationTimeoutMs",
+          "childFailureRetryLimit"
+        ]);
+        const shutdown = _DaemonPolicyCodec.section(values, "shutdown", [
+          "idleTimeoutMs",
+          "stopTimeoutMs",
+          "forcedTerminationReserveMaximumMs",
+          "controllerPollIntervalMs",
+          "processSignalExitTimeoutMs",
+          "processExitPollIntervalMs",
+          "resourceDrainAcknowledgementGraceMs",
+          "resourceDrainAcknowledgementPollIntervalMs"
+        ]);
+        const delivery = _DaemonPolicyCodec.section(values, "delivery", [
+          "postAcceptanceExecutionReattachmentLimit",
+          "resultTransferResumeLimitPerExecutionAttempt"
+        ]);
+        const output = _DaemonPolicyCodec.section(values, "output", [
+          "maximumChunkRawBytes",
+          "inlineRawBytes",
+          "maximumResultRawBytes",
+          "maximumAggregateSpoolRawBytes"
+        ]);
+        const resources = _DaemonPolicyCodec.section(values, "resources", [
+          "effectiveMemoryBytes",
+          "hardProcessRssBytes",
+          "softProcessRssBytes",
+          "resumeProcessRssBytes",
+          "workerMaxOldGenerationSizeMiB",
+          "supervisionIntervalMs",
+          "replacementWindowMs",
+          "replacementLimit",
+          "workerHeapSampleIntervalMs"
+        ]);
+        const diagnostics = _DaemonPolicyCodec.section(values, "diagnostics", [
+          "logRotateBytes",
+          "logBackupCount",
+          "maximumQueuedEvents",
+          "disconnectedTraceRetentionMs",
+          "maximumDisconnectedTraces"
+        ]);
+        for (const section of [
+          transport,
+          startup,
+          shutdown,
+          delivery,
+          output,
+          resources,
+          diagnostics
+        ]) {
+          for (const value of Object.values(section))
+            _DaemonPolicyCodec.nonnegativeInteger(value);
+        }
+        for (const [section, key] of [
+          [startup, "heartbeatIntervalMs"],
+          [startup, "authorizationPollIntervalMs"],
+          [startup, "observationPollIntervalMs"],
+          [shutdown, "controllerPollIntervalMs"],
+          [shutdown, "processExitPollIntervalMs"],
+          [shutdown, "resourceDrainAcknowledgementPollIntervalMs"],
+          [resources, "supervisionIntervalMs"],
+          [resources, "workerHeapSampleIntervalMs"]
+        ]) {
+          if (_DaemonPolicyCodec.integer(section, key) <= 0)
+            throw new Error("Invalid daemon policy");
+        }
+        const hardProcessRssBytes = _DaemonPolicyCodec.integer(resources, "hardProcessRssBytes");
+        const softProcessRssBytes = _DaemonPolicyCodec.integer(resources, "softProcessRssBytes");
+        const resumeProcessRssBytes = _DaemonPolicyCodec.integer(resources, "resumeProcessRssBytes");
+        if (hardProcessRssBytes <= softProcessRssBytes || softProcessRssBytes <= resumeProcessRssBytes) {
+          throw new Error("Invalid daemon policy");
+        }
+        const maximumChunkRawBytes = _DaemonPolicyCodec.integer(output, "maximumChunkRawBytes");
+        const inlineRawBytes = _DaemonPolicyCodec.integer(output, "inlineRawBytes");
+        const maximumResultRawBytes = _DaemonPolicyCodec.integer(output, "maximumResultRawBytes");
+        const maximumAggregateSpoolRawBytes = _DaemonPolicyCodec.integer(output, "maximumAggregateSpoolRawBytes");
+        if (maximumChunkRawBytes === 0 || maximumChunkRawBytes > inlineRawBytes || inlineRawBytes > maximumResultRawBytes || maximumResultRawBytes > maximumAggregateSpoolRawBytes) {
+          throw new Error("Invalid daemon policy");
+        }
+      }
+      static section(values, name, keys) {
+        const section = values[name];
+        if (!_DaemonPolicyCodec.isRecord(section))
+          throw new Error("Invalid daemon policy");
+        _DaemonPolicyCodec.exactKeys(section, keys);
+        return section;
+      }
+      static exactKeys(value, keys) {
+        const actual = Object.keys(value).sort();
+        const expected = [...keys].sort();
+        if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+          throw new Error("Invalid daemon policy");
+        }
+      }
+      static nonnegativeInteger(value) {
+        if (!Number.isSafeInteger(value) || value < 0) {
+          throw new Error("Invalid daemon policy");
+        }
+      }
+      static integer(section, key) {
+        const value = section[key];
+        _DaemonPolicyCodec.nonnegativeInteger(value);
+        return value;
+      }
+      static isRecord(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+      }
+    };
+  }
+});
+
+// ../../packages/daemon/dist/client/daemon-client.js
+var init_daemon_client = __esm({
+  "../../packages/daemon/dist/client/daemon-client.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/daemon/dist/client/daemon-controlled-failure-message.js
+var init_daemon_controlled_failure_message = __esm({
+  "../../packages/daemon/dist/client/daemon-controlled-failure-message.js"() {
+    "use strict";
+  }
+});
+
+// ../../packages/daemon/dist/index.js
+var init_dist = __esm({
+  "../../packages/daemon/dist/index.js"() {
+    "use strict";
+    init_daemon_command_name();
+    init_daemon_policy();
+    init_daemon_client();
+    init_daemon_controlled_failure_message();
+  }
+});
+
+// ../../packages/daemon/dist/diagnostics/failure-values.js
+import { isAbsolute } from "node:path";
+var DaemonFailureValues;
+var init_failure_values = __esm({
+  "../../packages/daemon/dist/diagnostics/failure-values.js"() {
+    "use strict";
+    DaemonFailureValues = class {
+      static phases = /* @__PURE__ */ new Set([
+        "state location",
+        "endpoint create",
+        "endpoint bind",
+        "endpoint connect",
+        "process spawn",
+        "warm-up",
+        "worker",
+        "transfer"
+      ]);
+      static reasons = /* @__PURE__ */ new Set([
+        "state-write-failed",
+        "endpoint-create-failed",
+        "endpoint-bind-denied",
+        "endpoint-connect-failed",
+        "daemon-connection-reset",
+        "process-spawn-failed",
+        "startup-failed",
+        "worker-failed",
+        "transfer-failed",
+        "process-terminated",
+        "daemon-incompatible"
+      ]);
+      static isFailure(value) {
+        if (!this.isObject(value))
+          return false;
+        return this.exactKeys(value, ["phase", "reason", "timestamp"], ["osCode"]) && typeof value.phase === "string" && this.phases.has(value.phase) && typeof value.reason === "string" && this.reasons.has(value.reason) && typeof value.timestamp === "number" && Number.isFinite(value.timestamp) && value.timestamp >= 0 && (value.osCode === void 0 || this.isOsCode(value.osCode));
+      }
+      static isEvent(value) {
+        if (!this.isObject(value))
+          return false;
+        return this.exactKeys(value, ["schemaVersion", "eventId", "workspaceRoot", "kind", "failure"], ["instanceId", "requestId"]) && value.schemaVersion === 1 && this.isCorrelation(value.eventId) && typeof value.workspaceRoot === "string" && isAbsolute(value.workspaceRoot) && typeof value.kind === "string" && ["startup-failure", "fallback", "termination"].includes(value.kind) && this.isFailure(value.failure) && (value.instanceId === void 0 || this.isCorrelation(value.instanceId)) && (value.requestId === void 0 || this.isCorrelation(value.requestId));
+      }
+      static isOsCode(value) {
+        return typeof value === "string" && /^(?:E[A-Z0-9_]{1,63}|ERR_[A-Z0-9_]{1,60})$/u.test(value);
+      }
+      static isCorrelation(value) {
+        return typeof value === "string" && /^[A-Za-z0-9:._-]{1,256}$/u.test(value);
+      }
+      static isObject(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+      }
+      static exactKeys(value, required, optional) {
+        return required.every((key) => key in value) && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+      }
+    };
+  }
+});
+
+// ../../packages/daemon/dist/process/runtime-values.js
+var DaemonRuntimeValues;
+var init_runtime_values = __esm({
+  "../../packages/daemon/dist/process/runtime-values.js"() {
+    "use strict";
+    init_dist();
+    DaemonRuntimeValues = class {
+      static isCommandName(value) {
+        return DAEMON_COMMAND_NAMES.includes(value);
+      }
+      static isRequestId(value) {
+        return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(value);
+      }
+    };
+  }
+});
+
+// ../../packages/daemon/dist/lifecycle/daemon-clock.js
+import { performance } from "node:perf_hooks";
+var NodeDaemonClock;
+var init_daemon_clock = __esm({
+  "../../packages/daemon/dist/lifecycle/daemon-clock.js"() {
+    "use strict";
+    NodeDaemonClock = class {
+      sources;
+      constructor(sources = {
+        wallNowMs: Date.now,
+        monotonicNowMs: () => performance.now()
+      }) {
+        this.sources = sources;
+      }
+      wallNowMs() {
+        return this.sources.wallNowMs();
+      }
+      monotonicNowMs() {
+        return this.sources.monotonicNowMs();
+      }
+    };
+  }
+});
+
+// ../../packages/daemon/dist/worker/navigation-worker-entry.js
+init_failure_recorder();
+init_dist();
+import { parentPort, workerData } from "node:worker_threads";
+import { getHeapStatistics } from "node:v8";
+
+// ../../packages/daemon/dist/daemon-executor.js
+init_state_write_errors();
+
+// ../../packages/daemon/dist/daemon-diagnostics.js
+var DaemonDiagnosticValues = class {
+  static isDiagnostics(value) {
+    return this.isObject(value, /* @__PURE__ */ new Set());
+  }
+  static isValue(value, ancestors) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+      return true;
+    if (typeof value === "number")
+      return Number.isFinite(value);
+    if (Array.isArray(value))
+      return this.isArray(value, ancestors);
+    return this.isObject(value, ancestors);
+  }
+  static isArray(value, ancestors) {
+    if (ancestors.has(value))
+      return false;
+    const descendants = new Set(ancestors).add(value);
+    return value.every((entry) => this.isValue(entry, descendants));
+  }
+  static isObject(value, ancestors) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+      return false;
+    if (ancestors.has(value))
+      return false;
+    const descendants = new Set(ancestors).add(value);
+    return Object.values(value).every((entry) => this.isValue(entry, descendants));
+  }
+};
+
+// ../../packages/daemon/dist/daemon-executor.js
+var ValidatedDaemonExecutorOutput = class {
+  output;
+  constructor(output) {
+    this.output = output;
+  }
+  async *records() {
+    for await (const value of this.output.records()) {
+      if (!DaemonExecutorValidation.isOutputRecord(value)) {
+        throw new Error("Invalid daemon executor output record");
+      }
+      yield value;
+    }
+  }
+  dispose() {
+    return this.output.dispose();
+  }
+};
+var ValidatedDaemonExecutor = class {
+  executor;
+  constructor(executor) {
+    this.executor = executor;
+  }
+  async initialize(workspaceRoot) {
+    const result = await this.executor.initialize(workspaceRoot);
+    if (!DaemonExecutorValidation.isInitializationResult(result)) {
+      throw new Error("Invalid daemon executor initialization result");
+    }
+    return result;
+  }
+  async execute(request) {
+    const result = await this.executor.execute(request);
+    if (!DaemonExecutorValidation.isExecutionResult(result)) {
+      throw new Error("Invalid daemon executor execution result");
+    }
+    return { ...result, output: new ValidatedDaemonExecutorOutput(result.output) };
+  }
+  releaseTransientResources() {
+    return this.executor.releaseTransientResources();
+  }
+};
+var DaemonExecutorModuleImporter = class {
+  static hostImporterModuleUrl = [
+    "data:text/javascript",
+    "export default moduleUrl => import(moduleUrl)"
+  ].join(",");
+  static async load(moduleUrl) {
+    const importer = await import(this.hostImporterModuleUrl);
+    return importer.default(moduleUrl);
+  }
+};
+var DaemonExecutorModuleLoader = class {
+  static async load(moduleUrl, options) {
+    if (!DaemonExecutorValidation.isFileUrl(moduleUrl)) {
+      throw new Error("Daemon executor module must use a file URL");
+    }
+    const loaded = await DaemonExecutorModuleImporter.load(moduleUrl);
+    if (!DaemonExecutorValidation.isRecord(loaded) || typeof loaded.createDaemonExecutor !== "function") {
+      throw new Error("Daemon executor module has no createDaemonExecutor factory");
+    }
+    const executor = await loaded.createDaemonExecutor(options);
+    if (!DaemonExecutorValidation.isExecutor(executor)) {
+      throw new Error("Daemon executor factory returned an invalid executor");
+    }
+    return new ValidatedDaemonExecutor(executor);
+  }
+};
+var DaemonExecutorValidation = class {
+  static isInitializationResult(value) {
+    if (!this.isRecord(value))
+      return false;
+    return this.hasExactKeys(value, this.keysWithDiagnostics(["fileCount"], value)) && this.isCount(value.fileCount) && this.isDiagnostics(value.diagnostics);
+  }
+  static isExecutionResult(value) {
+    if (!this.isRecord(value))
+      return false;
+    return this.hasExactKeys(value, this.keysWithDiagnostics(value.stateWriteFailure === void 0 ? ["exitCode", "output"] : ["exitCode", "output", "stateWriteFailure"], value)) && this.isCount(value.exitCode) && this.isOutput(value.output) && (value.stateWriteFailure === void 0 || DaemonStateWriteErrors.isFailure(value.stateWriteFailure)) && this.isDiagnostics(value.diagnostics);
+  }
+  static isOutputRecord(value) {
+    return this.isRecord(value) && this.hasExactKeys(value, ["stream", "bytes"]) && (value.stream === "stdout" || value.stream === "stderr") && value.bytes instanceof Uint8Array;
+  }
+  static isFileUrl(value) {
+    return typeof value === "string" && value.startsWith("file://");
+  }
+  static isExecutor(value) {
+    return this.isRecord(value) && typeof value.initialize === "function" && typeof value.execute === "function" && typeof value.releaseTransientResources === "function";
+  }
+  static isOutput(value) {
+    return this.isRecord(value) && typeof value.records === "function" && typeof value.dispose === "function";
+  }
+  static isDiagnostics(value) {
+    return value === void 0 || DaemonDiagnosticValues.isDiagnostics(value);
+  }
+  static keysWithDiagnostics(keys, value) {
+    return value.diagnostics === void 0 ? keys : [...keys, "diagnostics"];
+  }
+  static hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+  }
+  static isCount(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+  }
+  static isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+};
+
+// ../../packages/daemon/dist/worker/navigation-worker-entry.js
+init_daemon_policy();
+
+// ../../packages/daemon/dist/worker/worker-protocol.js
+init_failure_values();
+init_state_write_errors();
+init_dist();
+init_runtime_values();
+var DaemonNavigationWorkerProtocol = class {
+  static request(value) {
+    if (!this.isRecord(value) || !this.isGeneration(value.generation)) {
+      throw new Error("Invalid daemon navigation worker request");
+    }
+    if (value.kind === "initialize" && this.hasKeys(value, ["kind", "generation", "workspaceRoot"]) && this.isNonEmptyString(value.workspaceRoot)) {
+      return value;
+    }
+    if (value.kind === "execute" && this.hasKeys(value, ["kind", "generation", "requestId", "commandName", "request"]) && this.isNonEmptyString(value.requestId) && DaemonRuntimeValues.isCommandName(value.commandName) && this.isExecutionRequest(value.request)) {
+      return value;
+    }
+    if (value.kind === "output-ack" && this.hasKeys(value, ["kind", "generation", "requestId", "sequence"]) && this.isNonEmptyString(value.requestId) && this.isCount(value.sequence)) {
+      return value;
+    }
+    if (value.kind === "release-transient" && this.hasKeys(value, ["kind", "generation", "operationId"]) && this.isNonEmptyString(value.operationId)) {
+      return value;
+    }
+    if (value.kind === "close" && this.hasKeys(value, ["kind", "generation"])) {
+      return value;
+    }
+    throw new Error("Invalid daemon navigation worker request");
+  }
+  static response(value, maximumChunkRawBytes) {
+    if (!this.isRecord(value) || !this.isGeneration(value.generation)) {
+      throw new Error("Invalid daemon navigation worker response");
+    }
+    if (value.kind === "ready" && this.hasKeys(value, this.keysWithDiagnostics(["kind", "generation", "fileCount", "refresh", "startupDurations"], value)) && this.isCount(value.fileCount) && this.isRefresh(value.refresh) && this.isDurations(value.startupDurations, ["discoveryMs", "indexingMs", "totalMs"]) && this.isDiagnostics(value.diagnostics)) {
+      return value;
+    }
+    if (value.kind === "output-chunk" && this.hasKeys(value, ["kind", "generation", "requestId", "sequence", "stream", "bytes"]) && this.isNonEmptyString(value.requestId) && this.isCount(value.sequence) && (value.stream === "stdout" || value.stream === "stderr") && value.bytes instanceof Uint8Array && value.bytes.byteLength <= maximumChunkRawBytes) {
+      return value;
+    }
+    if (value.kind === "result" && this.hasKeys(value, this.keysWithDiagnostics(["kind", "generation", "requestId", "result", "refresh", "durations", "resources"], value)) && this.isNonEmptyString(value.requestId) && this.isExecutionResult(value.result) && this.isRefresh(value.refresh) && this.isDurations(value.durations, ["freshnessMs", "navigationMs", "renderMs", "outputMs"]) && this.isDiagnostics(value.diagnostics) && this.isWorkerResources(value.resources)) {
+      return value;
+    }
+    if (value.kind === "failed" && this.isFailed(value)) {
+      return value;
+    }
+    if (value.kind === "heap" && this.hasKeys(value, [
+      "kind",
+      "generation",
+      "operationId",
+      "usedHeapBytes",
+      "heapLimitBytes"
+    ]) && this.isNonEmptyString(value.operationId) && this.isCount(value.usedHeapBytes) && this.isCount(value.heapLimitBytes)) {
+      return value;
+    }
+    if (value.kind === "closed" && this.hasKeys(value, ["kind", "generation"])) {
+      return value;
+    }
+    throw new Error("Invalid daemon navigation worker response");
+  }
+  static isWorkerResources(value) {
+    return this.isRecord(value) && this.hasKeys(value, [
+      "workerHeapUsedBytes",
+      "peakWorkerHeapUsedBytes",
+      "workerHeapLimitBytes"
+    ]) && this.isCount(value.workerHeapUsedBytes) && this.isCount(value.peakWorkerHeapUsedBytes) && this.isCount(value.workerHeapLimitBytes) && value.peakWorkerHeapUsedBytes >= value.workerHeapUsedBytes;
+  }
+  static isExecutionRequest(value) {
+    if (!this.isRecord(value))
+      return false;
+    return this.hasKeys(value, ["argv", "cwd", "telemetryEnabled", "executionMode"]) && Array.isArray(value.argv) && value.argv.every((argument) => typeof argument === "string") && typeof value.cwd === "string" && typeof value.telemetryEnabled === "boolean" && (value.executionMode === "cold" || value.executionMode === "warm" || value.executionMode === "fallback");
+  }
+  static isDiagnostics(value) {
+    return value === void 0 || DaemonDiagnosticValues.isDiagnostics(value);
+  }
+  static keysWithDiagnostics(keys, value) {
+    return value.diagnostics === void 0 ? keys : [...keys, "diagnostics"];
+  }
+  static isExecutionResult(value) {
+    return this.isRecord(value) && this.hasKeys(value, value.stateWriteFailure === void 0 ? ["exitCode"] : ["exitCode", "stateWriteFailure"]) && this.isCount(value.exitCode) && (value.stateWriteFailure === void 0 || DaemonStateWriteErrors.isFailure(value.stateWriteFailure));
+  }
+  static isRefresh(value) {
+    return this.isRecord(value) && this.hasKeys(value, ["added", "changed", "removed", "unchanged"]) && this.isCount(value.added) && this.isCount(value.changed) && this.isCount(value.removed) && this.isCount(value.unchanged);
+  }
+  static isFailed(value) {
+    const keys = ["kind", "generation", "failureCode"];
+    if (value.requestId !== void 0)
+      keys.push("requestId");
+    if (value.operationId !== void 0)
+      keys.push("operationId");
+    if (value.errorName !== void 0)
+      keys.push("errorName");
+    if (value.osCode !== void 0)
+      keys.push("osCode");
+    return this.hasKeys(value, keys) && (value.requestId === void 0 || this.isNonEmptyString(value.requestId)) && (value.operationId === void 0 || this.isNonEmptyString(value.operationId)) && !(value.requestId !== void 0 && value.operationId !== void 0) && (value.failureCode === "initialization" || value.failureCode === "execution" || value.failureCode === "protocol" || value.failureCode === "resource") && (value.errorName === void 0 || this.isNonEmptyString(value.errorName)) && (value.osCode === void 0 || DaemonFailureValues.isOsCode(value.osCode));
+  }
+  static isDurations(value, keys) {
+    return this.isRecord(value) && this.hasKeys(value, keys) && keys.every((key) => this.isMetric(value[key]));
+  }
+  static hasKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    return actual.length === keys.length && actual.every((key, index) => key === [...keys].sort()[index]);
+  }
+  static isGeneration(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+  }
+  static isCount(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+  }
+  static isMetric(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+  }
+  static isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+  }
+  static isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+};
+
+// ../../packages/daemon/dist/worker/navigation-worker-entry.js
+init_daemon_clock();
+var DaemonNavigationWorkerEntry = class {
+  port;
+  data;
+  executor;
+  activeHeapMonitor;
+  tail = Promise.resolve();
+  outputAcknowledgements = /* @__PURE__ */ new Map();
+  policy;
+  clock = new NodeDaemonClock();
+  constructor(port, data2) {
+    this.port = port;
+    this.data = data2;
+    this.policy = DaemonPolicyCodec.deserialize(data2.policy);
+  }
+  run() {
+    this.port.on("message", (value) => {
+      if (typeof value === "object" && value !== null && "kind" in value && value.kind === "output-ack") {
+        try {
+          const request = DaemonNavigationWorkerProtocol.request(value);
+          if (request.kind !== "output-ack")
+            throw new Error("Invalid output acknowledgement");
+          this.acknowledgeOutput(request.requestId, request.sequence);
+          return;
+        } catch (error) {
+          this.fail("protocol", error);
+          return;
+        }
+      }
+      this.tail = this.tail.then(() => this.handle(value));
+    });
+  }
+  async handle(value) {
+    let request;
+    try {
+      request = DaemonNavigationWorkerProtocol.request(value);
+    } catch (error) {
+      this.fail("protocol", error);
+      return;
+    }
+    if (request.generation !== this.data.generation)
+      return;
+    if (request.kind === "initialize") {
+      await this.initialize(request.workspaceRoot);
+      return;
+    }
+    if (request.kind === "execute") {
+      await this.execute(request);
+      return;
+    }
+    if (request.kind === "release-transient") {
+      await this.releaseTransientResources(request.operationId);
+      return;
+    }
+    await this.close();
+  }
+  async initialize(workspaceRoot) {
+    const startedAt = this.clock.monotonicNowMs();
+    try {
+      this.executor = await DaemonExecutorModuleLoader.load(this.data.executorModuleUrl, {
+        stateDirectory: this.data.stateDirectory,
+        productVersion: this.data.productVersion,
+        sampleResources: () => this.activeHeapMonitor?.sample()
+      });
+      const initialized = await this.executor.initialize(workspaceRoot);
+      const totalMs = this.clock.monotonicNowMs() - startedAt;
+      this.send({
+        kind: "ready",
+        generation: this.data.generation,
+        fileCount: initialized.fileCount,
+        refresh: DaemonWorkerDiagnosticProjection.refresh(initialized.diagnostics),
+        startupDurations: {
+          ...DaemonWorkerDiagnosticProjection.startupDurations(initialized.diagnostics),
+          totalMs
+        },
+        ...initialized.diagnostics === void 0 ? {} : { diagnostics: initialized.diagnostics }
+      });
+    } catch (error) {
+      this.fail("initialization", error);
+    }
+  }
+  async execute(request) {
+    const heapMonitor = new WorkerHeapHighWater(this.policy.values.resources.workerHeapSampleIntervalMs);
+    this.activeHeapMonitor = heapMonitor;
+    try {
+      if (this.executor === void 0)
+        throw new Error("Navigation worker is not ready");
+      const result = await this.executor.execute(request.request);
+      heapMonitor.sample();
+      const outputStartedAt = this.clock.monotonicNowMs();
+      let sequence = 0;
+      for await (const record of result.output.records()) {
+        sequence = await this.sendOutput(request.requestId, sequence, record);
+        heapMonitor.sample();
+      }
+      await result.output.dispose();
+      const outputMs = this.clock.monotonicNowMs() - outputStartedAt;
+      const resources = heapMonitor.finish();
+      this.send({
+        kind: "result",
+        generation: this.data.generation,
+        requestId: request.requestId,
+        result: {
+          exitCode: result.exitCode,
+          ...result.stateWriteFailure === void 0 ? {} : { stateWriteFailure: result.stateWriteFailure }
+        },
+        refresh: DaemonWorkerDiagnosticProjection.refresh(result.diagnostics),
+        durations: {
+          ...DaemonWorkerDiagnosticProjection.commandDurations(result.diagnostics),
+          outputMs
+        },
+        ...result.diagnostics === void 0 ? {} : { diagnostics: result.diagnostics },
+        resources
+      });
+    } catch (error) {
+      this.fail("execution", error, { requestId: request.requestId });
+    } finally {
+      heapMonitor.close();
+      this.activeHeapMonitor = void 0;
+    }
+  }
+  async releaseTransientResources(operationId) {
+    try {
+      await this.executor?.releaseTransientResources();
+      const heap = getHeapStatistics();
+      this.send({
+        kind: "heap",
+        generation: this.data.generation,
+        operationId,
+        usedHeapBytes: heap.used_heap_size,
+        heapLimitBytes: heap.heap_size_limit
+      });
+    } catch (error) {
+      this.fail("resource", error, { operationId });
+    }
+  }
+  async close() {
+    await this.executor?.releaseTransientResources();
+    this.send({ kind: "closed", generation: this.data.generation });
+    this.port.close();
+  }
+  fail(failureCode, error, correlation = void 0) {
+    this.send({
+      kind: "failed",
+      generation: this.data.generation,
+      ...correlation,
+      failureCode,
+      ...error instanceof Error ? { errorName: error.name } : {},
+      ...DaemonFailureRecorder.osCode(error) === void 0 ? {} : { osCode: DaemonFailureRecorder.osCode(error) }
+    });
+  }
+  send(response) {
+    const validated = DaemonNavigationWorkerProtocol.response(response, this.policy.values.output.maximumChunkRawBytes);
+    if (validated.kind === "output-chunk") {
+      this.port.postMessage(validated, [validated.bytes.buffer]);
+      return;
+    }
+    this.port.postMessage(validated);
+  }
+  sendOutput(requestId, initialSequence, record) {
+    return this.sendOutputChunks(requestId, initialSequence, record);
+  }
+  async sendOutputChunks(requestId, initialSequence, record) {
+    let sequence = initialSequence;
+    if (record.bytes.byteLength === 0) {
+      await this.sendOutputChunk(requestId, sequence, record.stream, new Uint8Array());
+      return sequence + 1;
+    }
+    for (let offset = 0; offset < record.bytes.byteLength; offset += this.policy.values.output.maximumChunkRawBytes) {
+      const bytes = Uint8Array.from(record.bytes.subarray(offset, offset + this.policy.values.output.maximumChunkRawBytes));
+      await this.sendOutputChunk(requestId, sequence, record.stream, bytes);
+      sequence += 1;
+    }
+    return sequence;
+  }
+  sendOutputChunk(requestId, sequence, stream, bytes) {
+    const key = `${requestId}:${sequence}`;
+    if (this.outputAcknowledgements.has(key)) {
+      return Promise.reject(new Error("Duplicate worker output sequence"));
+    }
+    const acknowledgement = new Promise((resolve) => {
+      this.outputAcknowledgements.set(key, resolve);
+    });
+    this.send({
+      kind: "output-chunk",
+      generation: this.data.generation,
+      requestId,
+      sequence,
+      stream,
+      bytes
+    });
+    return acknowledgement;
+  }
+  acknowledgeOutput(requestId, sequence) {
+    const key = `${requestId}:${sequence}`;
+    const resolve = this.outputAcknowledgements.get(key);
+    if (resolve === void 0)
+      throw new Error("Unexpected worker output acknowledgement");
+    this.outputAcknowledgements.delete(key);
+    resolve();
+  }
+};
+var DaemonWorkerDiagnosticProjection = class {
+  static emptyRefresh = {
+    added: 0,
+    changed: 0,
+    removed: 0,
+    unchanged: 0
+  };
+  static refresh(diagnostics) {
+    const refresh = this.record(diagnostics?.refresh);
+    if (refresh === void 0)
+      return this.emptyRefresh;
+    return {
+      added: this.count(refresh.added),
+      changed: this.count(refresh.changed),
+      removed: this.count(refresh.removed),
+      unchanged: this.count(refresh.unchanged)
+    };
+  }
+  static startupDurations(diagnostics) {
+    const durations = this.record(diagnostics?.durations);
+    return {
+      discoveryMs: this.duration(durations?.discoveryMs),
+      indexingMs: this.duration(durations?.indexingMs)
+    };
+  }
+  static commandDurations(diagnostics) {
+    const durations = this.record(diagnostics?.durations);
+    return {
+      freshnessMs: this.duration(durations?.freshnessMs),
+      navigationMs: this.duration(durations?.navigationMs),
+      renderMs: this.duration(durations?.renderMs)
+    };
+  }
+  static record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+  }
+  static count(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : 0;
+  }
+  static duration(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+  }
+};
+var WorkerHeapHighWater = class {
+  currentUsedBytes = 0;
+  peakUsedBytes = 0;
+  heapLimitBytes = 0;
+  timer;
+  constructor(sampleIntervalMs) {
+    this.sample();
+    this.timer = setInterval(() => this.sample(), sampleIntervalMs);
+    this.timer.unref?.();
+  }
+  sample() {
+    const heap = getHeapStatistics();
+    this.currentUsedBytes = heap.used_heap_size;
+    this.peakUsedBytes = Math.max(this.peakUsedBytes, this.currentUsedBytes);
+    this.heapLimitBytes = heap.heap_size_limit;
+  }
+  finish() {
+    this.sample();
+    this.close();
+    return {
+      workerHeapUsedBytes: this.currentUsedBytes,
+      peakWorkerHeapUsedBytes: this.peakUsedBytes,
+      workerHeapLimitBytes: this.heapLimitBytes
+    };
+  }
+  close() {
+    clearInterval(this.timer);
+  }
+};
+if (parentPort === null)
+  throw new Error("Daemon navigation worker requires a parent port");
+var data = workerData;
+new DaemonNavigationWorkerEntry(parentPort, data).run();