@wildo-ai/platform-core-shared 1.1.11 → 1.1.13

package/dist/esm/runtime/http-server-env.contracts.js

@@ -18,6 +18,19 @@ export var HttpServerEnvKey;
 (function (HttpServerEnvKey) {
     /** Non-negative integer: the number of trusted reverse-proxy hops in front of this runtime. */
     HttpServerEnvKey["HTTP_TRUSTED_PROXY_HOPS"] = "HTTP_TRUSTED_PROXY_HOPS";
+    /**
+     * A SECOND address a host-run application backend accepts connections on, besides `HOST` (#3387): the host's Docker
+     * bridge gateway, so a compose minion or worker reaches the backend through `host.docker.internal`.
+     *
+     * On Docker Engine for Linux `host-gateway` resolves to the bridge gateway (for example `172.17.0.1`), and a process
+     * bound to the IPv4 loopback alone does not serve that address. Docker Desktop forwards the gateway to the host's
+     * loopback, so there the key is never written.
+     *
+     * Written by the native LOCAL lane only, when the CLI finds the bridge gateway assigned to an interface of this host.
+     * The HTTP server refuses a value that is not an IP literal or is an any-address, since either could serve the
+     * developer's network, and keeps serving its loopback when the address cannot be bound.
+     */
+    HttpServerEnvKey["CONTAINER_HOST_GATEWAY_LISTEN_HOST"] = "CONTAINER_HOST_GATEWAY_LISTEN_HOST";
 })(HttpServerEnvKey || (HttpServerEnvKey = {}));
 /**
  * The hops in front of a REMOTE runtime: both remote deployment lanes put exactly ONE HTTP reverse proxy

package/dist/esm/runtime/http-server-env.contracts.js.map

@@ -1 +1 @@
-{"version":3,"file":"http-server-env.contracts.js","sourceRoot":"","sources":["../../../../src/runtime/http-server-env.contracts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAN,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC1B,+FAA+F;IAC/F,uEAAmD,CAAA;AACrD,CAAC,EAHW,gBAAgB,KAAhB,gBAAgB,QAG3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AAExC;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAyB;IAC7D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,CAAC,CAAC;IACzD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,GAAG,gBAAgB,CAAC,uBAAuB,yCAAyC,KAAK,KAAK,CAAC,CAAC;IAClH,CAAC;IACD,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC;AACzB,CAAC","sourcesContent":["/**\n * How many HTTP reverse proxies sit in front of a runtime's HTTP server — the deployment fact Express's\n * `trust proxy` needs, and the only thing that makes `req.ip` the CLIENT's address rather than the last\n * proxy's (#1788).\n *\n * Every per-client-IP control in the engine — the machine-credential failure lockout, the per-endpoint\n * rate limits, the global HTTP limiter, the audit trail's client address — keys on `req.ip`. Behind a\n * proxy with `trust proxy` unset, `req.ip` is the proxy for EVERY caller, so all of them share one\n * bucket: one client presenting bad keys locks every machine caller out.\n *\n * It is a property of the DEPLOYMENT, not of the application, so it arrives in the process environment,\n * rendered by the lane that put the proxy there — like `HOST` and `PORT` — and is read at the one HTTP\n * server every runtime shares (applications, the dev companion and the platform services alike).\n * Absent means zero: no proxy is trusted, which is the safe reading — a trusted hop that is not really\n * there would let a client choose its own address through `X-Forwarded-For`.\n */\nexport enum HttpServerEnvKey {\n  /** Non-negative integer: the number of trusted reverse-proxy hops in front of this runtime. */\n  HTTP_TRUSTED_PROXY_HOPS = 'HTTP_TRUSTED_PROXY_HOPS',\n}\n\n/**\n * The hops in front of a REMOTE runtime: both remote deployment lanes put exactly ONE HTTP reverse proxy\n * (Traefik) before the backend — as the cluster ingress in the Kubernetes lane, as the TLS-terminating\n * edge in the remote compose lane. A local runtime is reached directly and trusts none.\n *\n * One hop is only the client's address if Traefik itself SAW the client. A cloud load balancer in front\n * of it works at TCP level and adds no forwarded header, so it is not a hop — but kube-proxy source-NATs\n * a LoadBalancer Service by default, and Traefik would then see a node. The Kubernetes lane's Traefik\n * values set `externalTrafficPolicy: Local` for exactly this reason; the compose lane publishes Traefik's\n * ports directly, which keeps the source address (#1788 review).\n *\n * The limit, stated rather than implied: trusting a hop COUNT means a caller that reaches the backend\n * WITHOUT Traefik — another pod in the same cluster — can name its own address in `X-Forwarded-For`.\n * Every such caller is one of this application's own runtimes or the platform, not an internet client,\n * and trusting Traefik's own addresses instead would need the cluster's pod network, which no lane\n * knows. The controls this protects are the ones aimed at the internet.\n */\nexport const REMOTE_EDGE_PROXY_HOPS = 1;\n\n/**\n * Read {@link HttpServerEnvKey.HTTP_TRUSTED_PROXY_HOPS}: an absent or empty value is 0; anything that is\n * not a non-negative integer is REFUSED, because silently reading a typo as 0 would collapse every\n * client into one rate-limit bucket without a word, and reading it as anything else would trust hops\n * that are not there.\n */\nexport function parseTrustedProxyHops(value: string | undefined): number {\n  if (value === undefined || value.trim() === '') return 0;\n  const trimmed = value.trim();\n  if (!/^\\d+$/.test(trimmed)) {\n    throw new Error(`${HttpServerEnvKey.HTTP_TRUSTED_PROXY_HOPS} must be a non-negative integer (got \"${value}\").`);\n  }\n  return Number(trimmed);\n}\n"]}
+{"version":3,"file":"http-server-env.contracts.js","sourceRoot":"","sources":["../../../src/runtime/http-server-env.contracts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAN,IAAY,gBAgBX;AAhBD,WAAY,gBAAgB;IAC1B,+FAA+F;IAC/F,uEAAmD,CAAA;IACnD;;;;;;;;;;;OAWG;IACH,6FAAyE,CAAA;AAC3E,CAAC,EAhBW,gBAAgB,KAAhB,gBAAgB,QAgB3B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AAExC;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAyB;IAC7D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE;QAAE,OAAO,CAAC,CAAC;IACzD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAC7B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,GAAG,gBAAgB,CAAC,uBAAuB,yCAAyC,KAAK,KAAK,CAAC,CAAC;IAClH,CAAC;IACD,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC;AACzB,CAAC","sourcesContent":["/**\n * How many HTTP reverse proxies sit in front of a runtime's HTTP server — the deployment fact Express's\n * `trust proxy` needs, and the only thing that makes `req.ip` the CLIENT's address rather than the last\n * proxy's (#1788).\n *\n * Every per-client-IP control in the engine — the machine-credential failure lockout, the per-endpoint\n * rate limits, the global HTTP limiter, the audit trail's client address — keys on `req.ip`. Behind a\n * proxy with `trust proxy` unset, `req.ip` is the proxy for EVERY caller, so all of them share one\n * bucket: one client presenting bad keys locks every machine caller out.\n *\n * It is a property of the DEPLOYMENT, not of the application, so it arrives in the process environment,\n * rendered by the lane that put the proxy there — like `HOST` and `PORT` — and is read at the one HTTP\n * server every runtime shares (applications, the dev companion and the platform services alike).\n * Absent means zero: no proxy is trusted, which is the safe reading — a trusted hop that is not really\n * there would let a client choose its own address through `X-Forwarded-For`.\n */\nexport enum HttpServerEnvKey {\n  /** Non-negative integer: the number of trusted reverse-proxy hops in front of this runtime. */\n  HTTP_TRUSTED_PROXY_HOPS = 'HTTP_TRUSTED_PROXY_HOPS',\n  /**\n   * A SECOND address a host-run application backend accepts connections on, besides `HOST` (#3387): the host's Docker\n   * bridge gateway, so a compose minion or worker reaches the backend through `host.docker.internal`.\n   *\n   * On Docker Engine for Linux `host-gateway` resolves to the bridge gateway (for example `172.17.0.1`), and a process\n   * bound to the IPv4 loopback alone does not serve that address. Docker Desktop forwards the gateway to the host's\n   * loopback, so there the key is never written.\n   *\n   * Written by the native LOCAL lane only, when the CLI finds the bridge gateway assigned to an interface of this host.\n   * The HTTP server refuses a value that is not an IP literal or is an any-address, since either could serve the\n   * developer's network, and keeps serving its loopback when the address cannot be bound.\n   */\n  CONTAINER_HOST_GATEWAY_LISTEN_HOST = 'CONTAINER_HOST_GATEWAY_LISTEN_HOST',\n}\n\n/**\n * The hops in front of a REMOTE runtime: both remote deployment lanes put exactly ONE HTTP reverse proxy\n * (Traefik) before the backend — as the cluster ingress in the Kubernetes lane, as the TLS-terminating\n * edge in the remote compose lane. A local runtime is reached directly and trusts none.\n *\n * One hop is only the client's address if Traefik itself SAW the client. A cloud load balancer in front\n * of it works at TCP level and adds no forwarded header, so it is not a hop — but kube-proxy source-NATs\n * a LoadBalancer Service by default, and Traefik would then see a node. The Kubernetes lane's Traefik\n * values set `externalTrafficPolicy: Local` for exactly this reason; the compose lane publishes Traefik's\n * ports directly, which keeps the source address (#1788 review).\n *\n * The limit, stated rather than implied: trusting a hop COUNT means a caller that reaches the backend\n * WITHOUT Traefik — another pod in the same cluster — can name its own address in `X-Forwarded-For`.\n * Every such caller is one of this application's own runtimes or the platform, not an internet client,\n * and trusting Traefik's own addresses instead would need the cluster's pod network, which no lane\n * knows. The controls this protects are the ones aimed at the internet.\n */\nexport const REMOTE_EDGE_PROXY_HOPS = 1;\n\n/**\n * Read {@link HttpServerEnvKey.HTTP_TRUSTED_PROXY_HOPS}: an absent or empty value is 0; anything that is\n * not a non-negative integer is REFUSED, because silently reading a typo as 0 would collapse every\n * client into one rate-limit bucket without a word, and reading it as anything else would trust hops\n * that are not there.\n */\nexport function parseTrustedProxyHops(value: string | undefined): number {\n  if (value === undefined || value.trim() === '') return 0;\n  const trimmed = value.trim();\n  if (!/^\\d+$/.test(trimmed)) {\n    throw new Error(`${HttpServerEnvKey.HTTP_TRUSTED_PROXY_HOPS} must be a non-negative integer (got \"${value}\").`);\n  }\n  return Number(trimmed);\n}\n"]}

package/dist/esm/runtime/local-dev-runtime-signals.contracts.d.ts

@@ -0,0 +1,239 @@
+import { z } from 'zod';
+/**
+ * The local dev loop's two RUNTIME-SIGNAL records: what an application package's compiler last did, and what the
+ * supervisor of an application runtime (the backend) is doing (#3212, #3214, #3215, #3216).
+ *
+ * ## Why these live here, beside the backend's start record
+ *
+ * Both records were born in the monorepo's dev orchestrator (`scripts/dev-orchestrator/local-dev-protocol.mjs`), a
+ * dependency-free script that only a FRAMEWORK DEVELOPER's application runs. An application created from the published
+ * framework (app-creator mode) ran neither: its shared library was `tsc-watch` plus a `tsc-alias` pass, and its backend
+ * was `node dist/index.js` started from the backend's own `tsc-watch --onSuccess`. Four defects of
+ * `app-creation-test-007` followed from that one absence:
+ *
+ * - nothing restarted the backend when the shared library it imports was rebuilt, so a tree that was already fixed stayed
+ *   down for 46 minutes (#3215);
+ * - the backend could start between the shared library's `tsc` emit and its alias pass, read extensionless imports and
+ *   die with `ERR_MODULE_NOT_FOUND`, and nothing brought it back (#3216);
+ * - a backend left behind by an earlier generation kept the port and served stale code while every rebuild's start died
+ *   on "port in use", and a watcher dead since a laptop sleep was never noticed (#3214);
+ * - the companion read the application's packages the instant a playbook had written their sources, before their
+ *   compiler had published, and stopped the whole creation loop on one stale read (#3212).
+ *
+ * The published framework now ships the writer of both records (`wildo-dev-runtime`, the program of
+ * `@wildo-ai/wildo-dev-runtime`, which runs this package's `./dev-runtime` code, #3263), so the same files exist in both
+ * modes, at the same paths, in the same shape. The companion reads them through THIS module and the
+ * framework-developer scripts keep writing them from their own copy of the vocabulary, which is why the values below
+ * are pinned against that script by a test rather than restated by hand.
+ *
+ * ## Where they live
+ *
+ * Under the application's runtime-signals home, `<app>/.wildo-saas/runtime-signals/`:
+ * `compilers/<package file name>.json` for a compiler, `supervisors/<label>.json` for a runtime supervisor.
+ */
+/** The protocol version both records carry. A reader refuses any other value rather than guessing its meaning. */
+export declare const LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION = 1;
+/** The application-relative runtime-signals home every record below lives under. */
+export declare const APPLICATION_RUNTIME_SIGNALS_RELATIVE_DIRECTORY = ".wildo-saas/runtime-signals";
+/** The directory, under the runtime-signals home, holding one compile observation per application package. */
+export declare const LOCAL_DEV_COMPILE_OBSERVATIONS_DIRECTORY = "compilers";
+/** The directory, under the runtime-signals home, holding one record per supervised runtime. */
+export declare const LOCAL_DEV_SUPERVISOR_OBSERVATIONS_DIRECTORY = "supervisors";
+export declare const LOCAL_DEV_COMPILE_OBSERVATION_KIND = "wildo.local-dev.compile-observation";
+export declare const LOCAL_DEV_SUPERVISOR_OBSERVATION_KIND = "wildo.local-dev.supervisor-observation";
+/**
+ * What an application package's compiler is doing. A package's `dist` may be READ only while its compiler is `READY`:
+ * every other state means the output is being written, or was left half-written, or is not being kept current at all.
+ */
+export declare enum LocalDevCompileState {
+    /** The compiler is starting and has not finished its first compilation. */
+    STARTING = "STARTING",
+    /** `tsc` reported a compilation START and has not reported its end: it may be writing `dist` right now. */
+    COMPILING = "COMPILING",
+    /**
+     * `tsc` finished with no error and the post-emit pass (the import-specifier rewrite) is running. The emitted files
+     * still carry extensionless relative imports that Node cannot resolve until this pass ends — the window #3216 measured.
+     */
+    FINALIZING = "FINALIZING",
+    /** The last compilation finished, its post-emit pass completed, and the emitted tree was verified. `dist` is current. */
+    READY = "READY",
+    /** The last compilation reported errors, or its post-emit pass failed. `dist` holds an earlier or a partial build. */
+    FAILED = "FAILED",
+    /** The compiler is not running. Nothing keeps `dist` current. */
+    STOPPED = "STOPPED"
+}
+/** What a runtime supervisor is doing with the runtime it owns. */
+export declare enum LocalDevSupervisorState {
+    /** Waiting to start the runtime: its build or a dependency's is not published yet, or a restart is under way. */
+    STARTING = "STARTING",
+    /** The runtime is running and was started by this supervisor. */
+    RUNNING = "RUNNING",
+    /** The runtime exited unexpectedly and a respawn is scheduled after a backoff. */
+    BACKOFF = "BACKOFF",
+    /**
+     * The supervisor will not start the runtime until something changes: `blocker` says what (a crash budget spent, a
+     * port another process holds). A new build of a package it loads resets it.
+     */
+    PAUSED = "PAUSED",
+    /** The supervisor stopped and its runtime with it. */
+    STOPPED = "STOPPED"
+}
+/**
+ * Why a supervisor is not running its runtime, as a closed vocabulary a reader can branch on.
+ *
+ * Kept apart from the free-text blockers the monorepo's supervisor publishes (a readiness reason, a migration owed)
+ * because the remedy differs per member: a held port is the dev stack's, a crash loop is usually a dependency that is
+ * down (#3365), and a spent budget is the application's own startup refusing. The `.mjs` mirror is
+ * `LocalDevSupervisorBlocker` in `scripts/dev-orchestrator/local-dev-protocol.mjs`.
+ */
+export declare enum LocalDevSupervisorBlocker {
+    /**
+     * PAUSED: the runtime crashed at every respawn of its budget AND its own startup refused (its start record says
+     * `startup-refused`), so a new build of a package it loads is what fixes it, and starts it again.
+     */
+    CRASH_RESPAWN_EXHAUSTED = "CRASH_RESPAWN_EXHAUSTED",
+    /**
+     * BACKOFF past the budget (#3365): the runtime keeps crashing and the supervisor keeps restarting it, the delay
+     * doubling up to a cap and never stopping (Kubernetes' CrashLoopBackOff). Published when the cause is a dependency
+     * that did not answer, or cannot be told: a database that comes back must bring its runtime back by itself.
+     * A reader treats it like a pause for "is the application up?": the runtime is not running between attempts.
+     */
+    CRASH_LOOP_BACKOFF = "CRASH_LOOP_BACKOFF",
+    /**
+     * A process this supervisor did not spawn listens on the runtime's port, so every start dies binding it. The record's
+     * `portHolder` names it. The supervisor starts the runtime the moment the port is free.
+     */
+    PORT_HELD_BY_FOREIGN_PROCESS = "PORT_HELD_BY_FOREIGN_PROCESS",
+    /**
+     * STOPPED (#2149): an app-creator COMPANION's supervisor (`wildo-dev-companion-supervised`) saw it crash more times
+     * than its window tolerates, stopped restarting it, and exited. Unlike {@link CRASH_RESPAWN_EXHAUSTED}, no build
+     * starts it again: only restarting `wildo local dev` does, after the cause in its log is fixed. The record outlives
+     * its producer on purpose, which is how `wildo local dev-status` can say the companion is down and why.
+     */
+    CRASH_LOOP_GAVE_UP = "CRASH_LOOP_GAVE_UP",
+    /**
+     * PAUSED (#3552): a dependency install is re-creating the application's `node_modules` (the build applied a
+     * composition scenario, or a person ran an install). A start now would boot against a half-installed tree, so the
+     * runtime is held, and a crash in this window is not counted against its budget. It starts again, with a fresh
+     * budget, the moment the install ends. See {@link LocalDevDependencyInstallRecord_Schema}.
+     */
+    DEPENDENCY_INSTALL_IN_FLIGHT = "DEPENDENCY_INSTALL_IN_FLIGHT"
+}
+/**
+ * The application-relative file, under the runtime-signals home, that says a dependency install is running in the
+ * application, or when the last one ended (#3552). See {@link LocalDevDependencyInstallRecord_Schema}.
+ */
+export declare const LOCAL_DEV_DEPENDENCY_INSTALL_RECORD_FILE = "dependency-install.json";
+export declare const LOCAL_DEV_DEPENDENCY_INSTALL_RECORD_KIND = "wildo.local-dev.dependency-install";
+/**
+ * Where a dependency install stands, as every dev-loop reader of {@link LocalDevDependencyInstallRecord_Schema} judges it.
+ */
+export declare enum LocalDevDependencyInstallPhase {
+    /** No install has been recorded in this application. */
+    NONE = "NONE",
+    /** An install is running: its writer is alive and its deadline has not passed. Nothing may start on the tree. */
+    IN_FLIGHT = "IN_FLIGHT",
+    /**
+     * The install is over: it finished (successfully or not), its writer died without finishing, or it outlived its
+     * deadline. Everything that compiled or started before it ended read a tree that has since changed.
+     */
+    ENDED = "ENDED"
+}
+/**
+ * The process found listening on a port. That SOMETHING listens is established by connecting to it; who it is comes
+ * from the operating system's tools (`lsof`, `ps`), which a host may lack, so every field but `port` may be unknown.
+ */
+export declare const LocalDevPortHolder_Schema: z.ZodObject<{
+    port: z.ZodNumber;
+    pid: z.ZodNullable<z.ZodNumber>;
+    ppid: z.ZodNullable<z.ZodNumber>;
+    startedAt: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodNullable<z.ZodString>;
+    command: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type LocalDevPortHolder = z.infer<typeof LocalDevPortHolder_Schema>;
+/**
+ * One application package's compiler, as its observer last published it. Loose (unknown keys kept) because the framework
+ * developer's observer writes further fields (its diagnostic, its producer kind) that no reader here depends on.
+ */
+export declare const LocalDevCompileObservation_Schema: z.ZodObject<{
+    kind: z.ZodLiteral<"wildo.local-dev.compile-observation">;
+    schemaVersion: z.ZodLiteral<1>;
+    producerPid: z.ZodNumber;
+    childPid: z.ZodNullable<z.ZodNumber>;
+    appRoot: z.ZodString;
+    packageRoot: z.ZodString;
+    packageName: z.ZodString;
+    state: z.ZodEnum<typeof LocalDevCompileState>;
+    heartbeatAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lastCompilationStartedAt: z.ZodNullable<z.ZodString>;
+    lastSuccessfulCompileAt: z.ZodNullable<z.ZodString>;
+    lastFailureAt: z.ZodNullable<z.ZodString>;
+    lastErrorCount: z.ZodNullable<z.ZodNumber>;
+}, z.core.$loose>;
+export type LocalDevCompileObservation = z.infer<typeof LocalDevCompileObservation_Schema>;
+/** One supervised runtime. Loose for the same reason as the compile observation. */
+export declare const LocalDevSupervisorObservation_Schema: z.ZodObject<{
+    kind: z.ZodLiteral<"wildo.local-dev.supervisor-observation">;
+    schemaVersion: z.ZodLiteral<1>;
+    producerPid: z.ZodNumber;
+    label: z.ZodString;
+    state: z.ZodEnum<typeof LocalDevSupervisorState>;
+    childPid: z.ZodNullable<z.ZodNumber>;
+    childStartedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    blocker: z.ZodNullable<z.ZodString>;
+    portHolder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        port: z.ZodNumber;
+        pid: z.ZodNullable<z.ZodNumber>;
+        ppid: z.ZodNullable<z.ZodNumber>;
+        startedAt: z.ZodNullable<z.ZodString>;
+        cwd: z.ZodNullable<z.ZodString>;
+        command: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    signalFilePath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    updatedAt: z.ZodString;
+}, z.core.$loose>;
+export type LocalDevSupervisorObservation = z.infer<typeof LocalDevSupervisorObservation_Schema>;
+/**
+ * A dependency install in an application, as its installer records it (#3552).
+ *
+ * ## Why it exists
+ *
+ * `pnpm install` re-creates the application's `node_modules` while `wildo local dev` runs against it. Measured on
+ * reference run 42666728304 (2026-11-09): the build's foundation step applied composition scenarios that added four
+ * minions and a documentation site, and installed them (16 s). In that window every compile watcher compiled against a
+ * half-installed tree (`TS2318 Cannot find global type 'Array'`, `TS6053 lib.dom.d.ts not found`) and nothing ever asked
+ * it to compile again; the backend's readiness stayed blocked on those failures; every companion introspection worker
+ * died on `Cannot find package 'zod'`; and the install re-created the virtual-store key of `@wildo-ai/framework-knowledge`
+ * without its compiled knowledge tree, so `GET /api/companion/creation/questions` answered 500 for as long as the run
+ * was watched. Nothing tied the install to the running stack.
+ *
+ * So the installer writes this record before the install (`finishedAt: null`) and again when it ends, and every dev-loop
+ * process reads it: a runtime supervisor HOLDS its runtime while the install is in flight and does not count a crash
+ * against its budget, then relaunches it (and, in a framework checkout, repairs the injected snapshots first); a
+ * compile observer restarts a watcher whose last compile began before the install ended.
+ *
+ * ## Why a pid and a deadline rather than a heartbeat
+ *
+ * Every other in-flight signal here is a heartbeat refreshed from a timer. An install is often run SYNCHRONOUSLY
+ * (`spawnSync` in the CLI), so no timer would beat during it. The writer's pid answers "still running?" and the
+ * deadline bounds a writer that hangs, so a record can never hold the stack for good.
+ *
+ * ## Why it is never removed
+ *
+ * The finished record is what tells a watcher that started compiling before the install ended to compile again. It is a
+ * cache in the sense of `one-source-of-truth.md`: deleting it costs one missed relaunch, never a fact.
+ */
+export declare const LocalDevDependencyInstallRecord_Schema: z.ZodObject<{
+    kind: z.ZodLiteral<"wildo.local-dev.dependency-install">;
+    schemaVersion: z.ZodLiteral<1>;
+    pid: z.ZodNumber;
+    startedAt: z.ZodString;
+    deadlineAt: z.ZodString;
+    finishedAt: z.ZodNullable<z.ZodString>;
+    succeeded: z.ZodNullable<z.ZodBoolean>;
+    initiator: z.ZodString;
+}, z.core.$loose>;
+export type LocalDevDependencyInstallRecord = z.infer<typeof LocalDevDependencyInstallRecord_Schema>;
+//# sourceMappingURL=local-dev-runtime-signals.contracts.d.ts.map

package/dist/esm/runtime/local-dev-runtime-signals.contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-dev-runtime-signals.contracts.d.ts","sourceRoot":"","sources":["../../../src/runtime/local-dev-runtime-signals.contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,kHAAkH;AAClH,eAAO,MAAM,0CAA0C,IAAI,CAAC;AAE5D,oFAAoF;AACpF,eAAO,MAAM,8CAA8C,gCAAgC,CAAC;AAE5F,8GAA8G;AAC9G,eAAO,MAAM,wCAAwC,cAAc,CAAC;AAEpE,gGAAgG;AAChG,eAAO,MAAM,2CAA2C,gBAAgB,CAAC;AAEzE,eAAO,MAAM,kCAAkC,wCAAwC,CAAC;AACxF,eAAO,MAAM,qCAAqC,2CAA2C,CAAC;AAE9F;;;GAGG;AACH,oBAAY,oBAAoB;IAC9B,2EAA2E;IAC3E,QAAQ,aAAa;IACrB,2GAA2G;IAC3G,SAAS,cAAc;IACvB;;;OAGG;IACH,UAAU,eAAe;IACzB,yHAAyH;IACzH,KAAK,UAAU;IACf,sHAAsH;IACtH,MAAM,WAAW;IACjB,iEAAiE;IACjE,OAAO,YAAY;CACpB;AAED,mEAAmE;AACnE,oBAAY,uBAAuB;IACjC,iHAAiH;IACjH,QAAQ,aAAa;IACrB,iEAAiE;IACjE,OAAO,YAAY;IACnB,kFAAkF;IAClF,OAAO,YAAY;IACnB;;;OAGG;IACH,MAAM,WAAW;IACjB,sDAAsD;IACtD,OAAO,YAAY;CACpB;AAED;;;;;;;GAOG;AACH,oBAAY,yBAAyB;IACnC;;;OAGG;IACH,uBAAuB,4BAA4B;IACnD;;;;;OAKG;IACH,kBAAkB,uBAAuB;IACzC;;;OAGG;IACH,4BAA4B,iCAAiC;IAC7D;;;;;OAKG;IACH,kBAAkB,uBAAuB;IACzC;;;;;OAKG;IACH,4BAA4B,iCAAiC;CAC9D;AAED;;;GAGG;AACH,eAAO,MAAM,wCAAwC,4BAA4B,CAAC;AAClF,eAAO,MAAM,wCAAwC,uCAAuC,CAAC;AAE7F;;GAEG;AACH,oBAAY,8BAA8B;IACxC,wDAAwD;IACxD,IAAI,SAAS;IACb,iHAAiH;IACjH,SAAS,cAAc;IACvB;;;OAGG;IACH,KAAK,UAAU;CAChB;AAID;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;;;iBAWpC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE3E;;;GAGG;AACH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;iBAkB5C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAE3F,oFAAoF;AACpF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;iBAuB/C,CAAC;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAEjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,sCAAsC;;;;;;;;;iBAcjD,CAAC;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sCAAsC,CAAC,CAAC"}

package/dist/esm/runtime/local-dev-runtime-signals.contracts.js

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+/**
+ * The local dev loop's two RUNTIME-SIGNAL records: what an application package's compiler last did, and what the
+ * supervisor of an application runtime (the backend) is doing (#3212, #3214, #3215, #3216).
+ *
+ * ## Why these live here, beside the backend's start record
+ *
+ * Both records were born in the monorepo's dev orchestrator (`scripts/dev-orchestrator/local-dev-protocol.mjs`), a
+ * dependency-free script that only a FRAMEWORK DEVELOPER's application runs. An application created from the published
+ * framework (app-creator mode) ran neither: its shared library was `tsc-watch` plus a `tsc-alias` pass, and its backend
+ * was `node dist/index.js` started from the backend's own `tsc-watch --onSuccess`. Four defects of
+ * `app-creation-test-007` followed from that one absence:
+ *
+ * - nothing restarted the backend when the shared library it imports was rebuilt, so a tree that was already fixed stayed
+ *   down for 46 minutes (#3215);
+ * - the backend could start between the shared library's `tsc` emit and its alias pass, read extensionless imports and
+ *   die with `ERR_MODULE_NOT_FOUND`, and nothing brought it back (#3216);
+ * - a backend left behind by an earlier generation kept the port and served stale code while every rebuild's start died
+ *   on "port in use", and a watcher dead since a laptop sleep was never noticed (#3214);
+ * - the companion read the application's packages the instant a playbook had written their sources, before their
+ *   compiler had published, and stopped the whole creation loop on one stale read (#3212).
+ *
+ * The published framework now ships the writer of both records (`wildo-dev-runtime`, the program of
+ * `@wildo-ai/wildo-dev-runtime`, which runs this package's `./dev-runtime` code, #3263), so the same files exist in both
+ * modes, at the same paths, in the same shape. The companion reads them through THIS module and the
+ * framework-developer scripts keep writing them from their own copy of the vocabulary, which is why the values below
+ * are pinned against that script by a test rather than restated by hand.
+ *
+ * ## Where they live
+ *
+ * Under the application's runtime-signals home, `<app>/.wildo-saas/runtime-signals/`:
+ * `compilers/<package file name>.json` for a compiler, `supervisors/<label>.json` for a runtime supervisor.
+ */
+/** The protocol version both records carry. A reader refuses any other value rather than guessing its meaning. */
+export const LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION = 1;
+/** The application-relative runtime-signals home every record below lives under. */
+export const APPLICATION_RUNTIME_SIGNALS_RELATIVE_DIRECTORY = '.wildo-saas/runtime-signals';
+/** The directory, under the runtime-signals home, holding one compile observation per application package. */
+export const LOCAL_DEV_COMPILE_OBSERVATIONS_DIRECTORY = 'compilers';
+/** The directory, under the runtime-signals home, holding one record per supervised runtime. */
+export const LOCAL_DEV_SUPERVISOR_OBSERVATIONS_DIRECTORY = 'supervisors';
+export const LOCAL_DEV_COMPILE_OBSERVATION_KIND = 'wildo.local-dev.compile-observation';
+export const LOCAL_DEV_SUPERVISOR_OBSERVATION_KIND = 'wildo.local-dev.supervisor-observation';
+/**
+ * What an application package's compiler is doing. A package's `dist` may be READ only while its compiler is `READY`:
+ * every other state means the output is being written, or was left half-written, or is not being kept current at all.
+ */
+export var LocalDevCompileState;
+(function (LocalDevCompileState) {
+    /** The compiler is starting and has not finished its first compilation. */
+    LocalDevCompileState["STARTING"] = "STARTING";
+    /** `tsc` reported a compilation START and has not reported its end: it may be writing `dist` right now. */
+    LocalDevCompileState["COMPILING"] = "COMPILING";
+    /**
+     * `tsc` finished with no error and the post-emit pass (the import-specifier rewrite) is running. The emitted files
+     * still carry extensionless relative imports that Node cannot resolve until this pass ends — the window #3216 measured.
+     */
+    LocalDevCompileState["FINALIZING"] = "FINALIZING";
+    /** The last compilation finished, its post-emit pass completed, and the emitted tree was verified. `dist` is current. */
+    LocalDevCompileState["READY"] = "READY";
+    /** The last compilation reported errors, or its post-emit pass failed. `dist` holds an earlier or a partial build. */
+    LocalDevCompileState["FAILED"] = "FAILED";
+    /** The compiler is not running. Nothing keeps `dist` current. */
+    LocalDevCompileState["STOPPED"] = "STOPPED";
+})(LocalDevCompileState || (LocalDevCompileState = {}));
+/** What a runtime supervisor is doing with the runtime it owns. */
+export var LocalDevSupervisorState;
+(function (LocalDevSupervisorState) {
+    /** Waiting to start the runtime: its build or a dependency's is not published yet, or a restart is under way. */
+    LocalDevSupervisorState["STARTING"] = "STARTING";
+    /** The runtime is running and was started by this supervisor. */
+    LocalDevSupervisorState["RUNNING"] = "RUNNING";
+    /** The runtime exited unexpectedly and a respawn is scheduled after a backoff. */
+    LocalDevSupervisorState["BACKOFF"] = "BACKOFF";
+    /**
+     * The supervisor will not start the runtime until something changes: `blocker` says what (a crash budget spent, a
+     * port another process holds). A new build of a package it loads resets it.
+     */
+    LocalDevSupervisorState["PAUSED"] = "PAUSED";
+    /** The supervisor stopped and its runtime with it. */
+    LocalDevSupervisorState["STOPPED"] = "STOPPED";
+})(LocalDevSupervisorState || (LocalDevSupervisorState = {}));
+/**
+ * Why a supervisor is not running its runtime, as a closed vocabulary a reader can branch on.
+ *
+ * Kept apart from the free-text blockers the monorepo's supervisor publishes (a readiness reason, a migration owed)
+ * because the remedy differs per member: a held port is the dev stack's, a crash loop is usually a dependency that is
+ * down (#3365), and a spent budget is the application's own startup refusing. The `.mjs` mirror is
+ * `LocalDevSupervisorBlocker` in `scripts/dev-orchestrator/local-dev-protocol.mjs`.
+ */
+export var LocalDevSupervisorBlocker;
+(function (LocalDevSupervisorBlocker) {
+    /**
+     * PAUSED: the runtime crashed at every respawn of its budget AND its own startup refused (its start record says
+     * `startup-refused`), so a new build of a package it loads is what fixes it, and starts it again.
+     */
+    LocalDevSupervisorBlocker["CRASH_RESPAWN_EXHAUSTED"] = "CRASH_RESPAWN_EXHAUSTED";
+    /**
+     * BACKOFF past the budget (#3365): the runtime keeps crashing and the supervisor keeps restarting it, the delay
+     * doubling up to a cap and never stopping (Kubernetes' CrashLoopBackOff). Published when the cause is a dependency
+     * that did not answer, or cannot be told: a database that comes back must bring its runtime back by itself.
+     * A reader treats it like a pause for "is the application up?": the runtime is not running between attempts.
+     */
+    LocalDevSupervisorBlocker["CRASH_LOOP_BACKOFF"] = "CRASH_LOOP_BACKOFF";
+    /**
+     * A process this supervisor did not spawn listens on the runtime's port, so every start dies binding it. The record's
+     * `portHolder` names it. The supervisor starts the runtime the moment the port is free.
+     */
+    LocalDevSupervisorBlocker["PORT_HELD_BY_FOREIGN_PROCESS"] = "PORT_HELD_BY_FOREIGN_PROCESS";
+    /**
+     * STOPPED (#2149): an app-creator COMPANION's supervisor (`wildo-dev-companion-supervised`) saw it crash more times
+     * than its window tolerates, stopped restarting it, and exited. Unlike {@link CRASH_RESPAWN_EXHAUSTED}, no build
+     * starts it again: only restarting `wildo local dev` does, after the cause in its log is fixed. The record outlives
+     * its producer on purpose, which is how `wildo local dev-status` can say the companion is down and why.
+     */
+    LocalDevSupervisorBlocker["CRASH_LOOP_GAVE_UP"] = "CRASH_LOOP_GAVE_UP";
+    /**
+     * PAUSED (#3552): a dependency install is re-creating the application's `node_modules` (the build applied a
+     * composition scenario, or a person ran an install). A start now would boot against a half-installed tree, so the
+     * runtime is held, and a crash in this window is not counted against its budget. It starts again, with a fresh
+     * budget, the moment the install ends. See {@link LocalDevDependencyInstallRecord_Schema}.
+     */
+    LocalDevSupervisorBlocker["DEPENDENCY_INSTALL_IN_FLIGHT"] = "DEPENDENCY_INSTALL_IN_FLIGHT";
+})(LocalDevSupervisorBlocker || (LocalDevSupervisorBlocker = {}));
+/**
+ * The application-relative file, under the runtime-signals home, that says a dependency install is running in the
+ * application, or when the last one ended (#3552). See {@link LocalDevDependencyInstallRecord_Schema}.
+ */
+export const LOCAL_DEV_DEPENDENCY_INSTALL_RECORD_FILE = 'dependency-install.json';
+export const LOCAL_DEV_DEPENDENCY_INSTALL_RECORD_KIND = 'wildo.local-dev.dependency-install';
+/**
+ * Where a dependency install stands, as every dev-loop reader of {@link LocalDevDependencyInstallRecord_Schema} judges it.
+ */
+export var LocalDevDependencyInstallPhase;
+(function (LocalDevDependencyInstallPhase) {
+    /** No install has been recorded in this application. */
+    LocalDevDependencyInstallPhase["NONE"] = "NONE";
+    /** An install is running: its writer is alive and its deadline has not passed. Nothing may start on the tree. */
+    LocalDevDependencyInstallPhase["IN_FLIGHT"] = "IN_FLIGHT";
+    /**
+     * The install is over: it finished (successfully or not), its writer died without finishing, or it outlived its
+     * deadline. Everything that compiled or started before it ended read a tree that has since changed.
+     */
+    LocalDevDependencyInstallPhase["ENDED"] = "ENDED";
+})(LocalDevDependencyInstallPhase || (LocalDevDependencyInstallPhase = {}));
+const isoTimestamp = z.string().refine((value) => Number.isFinite(Date.parse(value)), 'an ISO-8601 timestamp');
+/**
+ * The process found listening on a port. That SOMETHING listens is established by connecting to it; who it is comes
+ * from the operating system's tools (`lsof`, `ps`), which a host may lack, so every field but `port` may be unknown.
+ */
+export const LocalDevPortHolder_Schema = z.object({
+    port: z.number().int().positive(),
+    pid: z.number().int().positive().nullable(),
+    /** The holder's parent. `1` means it was re-parented to the init process: its own parent is gone (an orphan). */
+    ppid: z.number().int().nonnegative().nullable(),
+    /** When the holder started, as `ps` reports it. */
+    startedAt: z.string().nullable(),
+    /** The holder's working directory. */
+    cwd: z.string().nullable(),
+    /** The holder's command line, truncated. */
+    command: z.string().nullable(),
+});
+/**
+ * One application package's compiler, as its observer last published it. Loose (unknown keys kept) because the framework
+ * developer's observer writes further fields (its diagnostic, its producer kind) that no reader here depends on.
+ */
+export const LocalDevCompileObservation_Schema = z.looseObject({
+    kind: z.literal(LOCAL_DEV_COMPILE_OBSERVATION_KIND),
+    schemaVersion: z.literal(LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION),
+    producerPid: z.number().int().positive(),
+    /** The compiler process the producer owns, or null when none runs. */
+    childPid: z.number().int().positive().nullable(),
+    appRoot: z.string().min(1),
+    packageRoot: z.string().min(1),
+    packageName: z.string().min(1),
+    state: z.enum(LocalDevCompileState),
+    heartbeatAt: isoTimestamp,
+    updatedAt: isoTimestamp,
+    /** When the compiler last reported a compilation start. */
+    lastCompilationStartedAt: isoTimestamp.nullable(),
+    /** When a compilation last ended READY: emitted, post-processed and verified. */
+    lastSuccessfulCompileAt: isoTimestamp.nullable(),
+    lastFailureAt: isoTimestamp.nullable(),
+    lastErrorCount: z.number().int().nonnegative().nullable(),
+});
+/** One supervised runtime. Loose for the same reason as the compile observation. */
+export const LocalDevSupervisorObservation_Schema = z.looseObject({
+    kind: z.literal(LOCAL_DEV_SUPERVISOR_OBSERVATION_KIND),
+    schemaVersion: z.literal(LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION),
+    producerPid: z.number().int().positive(),
+    label: z.string().min(1),
+    state: z.enum(LocalDevSupervisorState),
+    childPid: z.number().int().positive().nullable(),
+    /** When the current (or last) runtime child was started. */
+    childStartedAt: isoTimestamp.nullable().optional(),
+    /** A free-text reason (the monorepo supervisor's), or one of {@link LocalDevSupervisorBlocker}. */
+    blocker: z.string().nullable(),
+    /** Set with {@link LocalDevSupervisorBlocker.PORT_HELD_BY_FOREIGN_PROCESS}: the process that holds the port. */
+    portHolder: LocalDevPortHolder_Schema.nullable().optional(),
+    /**
+     * The file whose change asks this supervisor to restart its runtime (`<runtime-signals home>/<label>.signal`); `null`
+     * when the supervisor honours no such request. ABSENT from a writer that predates the field, which a reader treats as
+     * the conventional `<label>.signal` (the CLI does). Three writers set it: the monorepo's `runtime-supervisor.mjs`
+     * since #1031 and `wildo-dev-runtime serve` since #2134, each to its file (which is how `wildo secrets set` brings a
+     * changed key to a created application's running backend, minion or worker), and the app-creator companion's
+     * supervisor since #2149, to `null`: it honours no request, because the companion loads a changed key in place.
+     */
+    signalFilePath: z.string().min(1).nullable().optional(),
+    updatedAt: isoTimestamp,
+});
+/**
+ * A dependency install in an application, as its installer records it (#3552).
+ *
+ * ## Why it exists
+ *
+ * `pnpm install` re-creates the application's `node_modules` while `wildo local dev` runs against it. Measured on
+ * reference run 42666728304 (2026-11-09): the build's foundation step applied composition scenarios that added four
+ * minions and a documentation site, and installed them (16 s). In that window every compile watcher compiled against a
+ * half-installed tree (`TS2318 Cannot find global type 'Array'`, `TS6053 lib.dom.d.ts not found`) and nothing ever asked
+ * it to compile again; the backend's readiness stayed blocked on those failures; every companion introspection worker
+ * died on `Cannot find package 'zod'`; and the install re-created the virtual-store key of `@wildo-ai/framework-knowledge`
+ * without its compiled knowledge tree, so `GET /api/companion/creation/questions` answered 500 for as long as the run
+ * was watched. Nothing tied the install to the running stack.
+ *
+ * So the installer writes this record before the install (`finishedAt: null`) and again when it ends, and every dev-loop
+ * process reads it: a runtime supervisor HOLDS its runtime while the install is in flight and does not count a crash
+ * against its budget, then relaunches it (and, in a framework checkout, repairs the injected snapshots first); a
+ * compile observer restarts a watcher whose last compile began before the install ended.
+ *
+ * ## Why a pid and a deadline rather than a heartbeat
+ *
+ * Every other in-flight signal here is a heartbeat refreshed from a timer. An install is often run SYNCHRONOUSLY
+ * (`spawnSync` in the CLI), so no timer would beat during it. The writer's pid answers "still running?" and the
+ * deadline bounds a writer that hangs, so a record can never hold the stack for good.
+ *
+ * ## Why it is never removed
+ *
+ * The finished record is what tells a watcher that started compiling before the install ended to compile again. It is a
+ * cache in the sense of `one-source-of-truth.md`: deleting it costs one missed relaunch, never a fact.
+ */
+export const LocalDevDependencyInstallRecord_Schema = z.looseObject({
+    kind: z.literal(LOCAL_DEV_DEPENDENCY_INSTALL_RECORD_KIND),
+    schemaVersion: z.literal(LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION),
+    /** The process running the install (the companion, or the CLI). */
+    pid: z.number().int().positive(),
+    startedAt: isoTimestamp,
+    /** Past this instant the install is treated as ended, whatever its writer says. */
+    deadlineAt: isoTimestamp,
+    /** When the install ended, or `null` while it runs. */
+    finishedAt: isoTimestamp.nullable(),
+    /** Whether it succeeded, or `null` while it runs. */
+    succeeded: z.boolean().nullable(),
+    /** Who installed, for a reader of the record: `foundation`, `wildo update`, … */
+    initiator: z.string().min(1),
+});
+//# sourceMappingURL=local-dev-runtime-signals.contracts.js.map

package/dist/esm/runtime/local-dev-runtime-signals.contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-dev-runtime-signals.contracts.js","sourceRoot":"","sources":["../../../src/runtime/local-dev-runtime-signals.contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,kHAAkH;AAClH,MAAM,CAAC,MAAM,0CAA0C,GAAG,CAAC,CAAC;AAE5D,oFAAoF;AACpF,MAAM,CAAC,MAAM,8CAA8C,GAAG,6BAA6B,CAAC;AAE5F,8GAA8G;AAC9G,MAAM,CAAC,MAAM,wCAAwC,GAAG,WAAW,CAAC;AAEpE,gGAAgG;AAChG,MAAM,CAAC,MAAM,2CAA2C,GAAG,aAAa,CAAC;AAEzE,MAAM,CAAC,MAAM,kCAAkC,GAAG,qCAAqC,CAAC;AACxF,MAAM,CAAC,MAAM,qCAAqC,GAAG,wCAAwC,CAAC;AAE9F;;;GAGG;AACH,MAAM,CAAN,IAAY,oBAgBX;AAhBD,WAAY,oBAAoB;IAC9B,2EAA2E;IAC3E,6CAAqB,CAAA;IACrB,2GAA2G;IAC3G,+CAAuB,CAAA;IACvB;;;OAGG;IACH,iDAAyB,CAAA;IACzB,yHAAyH;IACzH,uCAAe,CAAA;IACf,sHAAsH;IACtH,yCAAiB,CAAA;IACjB,iEAAiE;IACjE,2CAAmB,CAAA;AACrB,CAAC,EAhBW,oBAAoB,KAApB,oBAAoB,QAgB/B;AAED,mEAAmE;AACnE,MAAM,CAAN,IAAY,uBAcX;AAdD,WAAY,uBAAuB;IACjC,iHAAiH;IACjH,gDAAqB,CAAA;IACrB,iEAAiE;IACjE,8CAAmB,CAAA;IACnB,kFAAkF;IAClF,8CAAmB,CAAA;IACnB;;;OAGG;IACH,4CAAiB,CAAA;IACjB,sDAAsD;IACtD,8CAAmB,CAAA;AACrB,CAAC,EAdW,uBAAuB,KAAvB,uBAAuB,QAclC;AAED;;;;;;;GAOG;AACH,MAAM,CAAN,IAAY,yBAgCX;AAhCD,WAAY,yBAAyB;IACnC;;;OAGG;IACH,gFAAmD,CAAA;IACnD;;;;;OAKG;IACH,sEAAyC,CAAA;IACzC;;;OAGG;IACH,0FAA6D,CAAA;IAC7D;;;;;OAKG;IACH,sEAAyC,CAAA;IACzC;;;;;OAKG;IACH,0FAA6D,CAAA;AAC/D,CAAC,EAhCW,yBAAyB,KAAzB,yBAAyB,QAgCpC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,wCAAwC,GAAG,yBAAyB,CAAC;AAClF,MAAM,CAAC,MAAM,wCAAwC,GAAG,oCAAoC,CAAC;AAE7F;;GAEG;AACH,MAAM,CAAN,IAAY,8BAUX;AAVD,WAAY,8BAA8B;IACxC,wDAAwD;IACxD,+CAAa,CAAA;IACb,iHAAiH;IACjH,yDAAuB,CAAA;IACvB;;;OAGG;IACH,iDAAe,CAAA;AACjB,CAAC,EAVW,8BAA8B,KAA9B,8BAA8B,QAUzC;AAED,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAAC;AAE/G;;;GAGG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC;IAChD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IACjC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC3C,iHAAiH;IACjH,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;IAC/C,mDAAmD;IACnD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,sCAAsC;IACtC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC1B,4CAA4C;IAC5C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,CAAC,WAAW,CAAC;IAC7D,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,kCAAkC,CAAC;IACnD,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,0CAA0C,CAAC;IACpE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IACxC,sEAAsE;IACtE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAChD,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC;IACnC,WAAW,EAAE,YAAY;IACzB,SAAS,EAAE,YAAY;IACvB,2DAA2D;IAC3D,wBAAwB,EAAE,YAAY,CAAC,QAAQ,EAAE;IACjD,iFAAiF;IACjF,uBAAuB,EAAE,YAAY,CAAC,QAAQ,EAAE;IAChD,aAAa,EAAE,YAAY,CAAC,QAAQ,EAAE;IACtC,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;CAC1D,CAAC,CAAC;AAGH,oFAAoF;AACpF,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAAC,CAAC,WAAW,CAAC;IAChE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,qCAAqC,CAAC;IACtD,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,0CAA0C,CAAC;IACpE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IACxC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC;IACtC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAChD,4DAA4D;IAC5D,cAAc,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAClD,mGAAmG;IACnG,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,gHAAgH;IAChH,UAAU,EAAE,yBAAyB,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAC3D;;;;;;;OAOG;IACH,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IACvD,SAAS,EAAE,YAAY;CACxB,CAAC,CAAC;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,CAAC,CAAC,WAAW,CAAC;IAClE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,wCAAwC,CAAC;IACzD,aAAa,EAAE,CAAC,CAAC,OAAO,CAAC,0CAA0C,CAAC;IACpE,mEAAmE;IACnE,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;IAChC,SAAS,EAAE,YAAY;IACvB,mFAAmF;IACnF,UAAU,EAAE,YAAY;IACxB,uDAAuD;IACvD,UAAU,EAAE,YAAY,CAAC,QAAQ,EAAE;IACnC,qDAAqD;IACrD,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACjC,iFAAiF;IACjF,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC7B,CAAC,CAAC","sourcesContent":["import { z } from 'zod';\n\n/**\n * The local dev loop's two RUNTIME-SIGNAL records: what an application package's compiler last did, and what the\n * supervisor of an application runtime (the backend) is doing (#3212, #3214, #3215, #3216).\n *\n * ## Why these live here, beside the backend's start record\n *\n * Both records were born in the monorepo's dev orchestrator (`scripts/dev-orchestrator/local-dev-protocol.mjs`), a\n * dependency-free script that only a FRAMEWORK DEVELOPER's application runs. An application created from the published\n * framework (app-creator mode) ran neither: its shared library was `tsc-watch` plus a `tsc-alias` pass, and its backend\n * was `node dist/index.js` started from the backend's own `tsc-watch --onSuccess`. Four defects of\n * `app-creation-test-007` followed from that one absence:\n *\n * - nothing restarted the backend when the shared library it imports was rebuilt, so a tree that was already fixed stayed\n *   down for 46 minutes (#3215);\n * - the backend could start between the shared library's `tsc` emit and its alias pass, read extensionless imports and\n *   die with `ERR_MODULE_NOT_FOUND`, and nothing brought it back (#3216);\n * - a backend left behind by an earlier generation kept the port and served stale code while every rebuild's start died\n *   on \"port in use\", and a watcher dead since a laptop sleep was never noticed (#3214);\n * - the companion read the application's packages the instant a playbook had written their sources, before their\n *   compiler had published, and stopped the whole creation loop on one stale read (#3212).\n *\n * The published framework now ships the writer of both records (`wildo-dev-runtime`, the program of\n * `@wildo-ai/wildo-dev-runtime`, which runs this package's `./dev-runtime` code, #3263), so the same files exist in both\n * modes, at the same paths, in the same shape. The companion reads them through THIS module and the\n * framework-developer scripts keep writing them from their own copy of the vocabulary, which is why the values below\n * are pinned against that script by a test rather than restated by hand.\n *\n * ## Where they live\n *\n * Under the application's runtime-signals home, `<app>/.wildo-saas/runtime-signals/`:\n * `compilers/<package file name>.json` for a compiler, `supervisors/<label>.json` for a runtime supervisor.\n */\n\n/** The protocol version both records carry. A reader refuses any other value rather than guessing its meaning. */\nexport const LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION = 1;\n\n/** The application-relative runtime-signals home every record below lives under. */\nexport const APPLICATION_RUNTIME_SIGNALS_RELATIVE_DIRECTORY = '.wildo-saas/runtime-signals';\n\n/** The directory, under the runtime-signals home, holding one compile observation per application package. */\nexport const LOCAL_DEV_COMPILE_OBSERVATIONS_DIRECTORY = 'compilers';\n\n/** The directory, under the runtime-signals home, holding one record per supervised runtime. */\nexport const LOCAL_DEV_SUPERVISOR_OBSERVATIONS_DIRECTORY = 'supervisors';\n\nexport const LOCAL_DEV_COMPILE_OBSERVATION_KIND = 'wildo.local-dev.compile-observation';\nexport const LOCAL_DEV_SUPERVISOR_OBSERVATION_KIND = 'wildo.local-dev.supervisor-observation';\n\n/**\n * What an application package's compiler is doing. A package's `dist` may be READ only while its compiler is `READY`:\n * every other state means the output is being written, or was left half-written, or is not being kept current at all.\n */\nexport enum LocalDevCompileState {\n  /** The compiler is starting and has not finished its first compilation. */\n  STARTING = 'STARTING',\n  /** `tsc` reported a compilation START and has not reported its end: it may be writing `dist` right now. */\n  COMPILING = 'COMPILING',\n  /**\n   * `tsc` finished with no error and the post-emit pass (the import-specifier rewrite) is running. The emitted files\n   * still carry extensionless relative imports that Node cannot resolve until this pass ends — the window #3216 measured.\n   */\n  FINALIZING = 'FINALIZING',\n  /** The last compilation finished, its post-emit pass completed, and the emitted tree was verified. `dist` is current. */\n  READY = 'READY',\n  /** The last compilation reported errors, or its post-emit pass failed. `dist` holds an earlier or a partial build. */\n  FAILED = 'FAILED',\n  /** The compiler is not running. Nothing keeps `dist` current. */\n  STOPPED = 'STOPPED',\n}\n\n/** What a runtime supervisor is doing with the runtime it owns. */\nexport enum LocalDevSupervisorState {\n  /** Waiting to start the runtime: its build or a dependency's is not published yet, or a restart is under way. */\n  STARTING = 'STARTING',\n  /** The runtime is running and was started by this supervisor. */\n  RUNNING = 'RUNNING',\n  /** The runtime exited unexpectedly and a respawn is scheduled after a backoff. */\n  BACKOFF = 'BACKOFF',\n  /**\n   * The supervisor will not start the runtime until something changes: `blocker` says what (a crash budget spent, a\n   * port another process holds). A new build of a package it loads resets it.\n   */\n  PAUSED = 'PAUSED',\n  /** The supervisor stopped and its runtime with it. */\n  STOPPED = 'STOPPED',\n}\n\n/**\n * Why a supervisor is not running its runtime, as a closed vocabulary a reader can branch on.\n *\n * Kept apart from the free-text blockers the monorepo's supervisor publishes (a readiness reason, a migration owed)\n * because the remedy differs per member: a held port is the dev stack's, a crash loop is usually a dependency that is\n * down (#3365), and a spent budget is the application's own startup refusing. The `.mjs` mirror is\n * `LocalDevSupervisorBlocker` in `scripts/dev-orchestrator/local-dev-protocol.mjs`.\n */\nexport enum LocalDevSupervisorBlocker {\n  /**\n   * PAUSED: the runtime crashed at every respawn of its budget AND its own startup refused (its start record says\n   * `startup-refused`), so a new build of a package it loads is what fixes it, and starts it again.\n   */\n  CRASH_RESPAWN_EXHAUSTED = 'CRASH_RESPAWN_EXHAUSTED',\n  /**\n   * BACKOFF past the budget (#3365): the runtime keeps crashing and the supervisor keeps restarting it, the delay\n   * doubling up to a cap and never stopping (Kubernetes' CrashLoopBackOff). Published when the cause is a dependency\n   * that did not answer, or cannot be told: a database that comes back must bring its runtime back by itself.\n   * A reader treats it like a pause for \"is the application up?\": the runtime is not running between attempts.\n   */\n  CRASH_LOOP_BACKOFF = 'CRASH_LOOP_BACKOFF',\n  /**\n   * A process this supervisor did not spawn listens on the runtime's port, so every start dies binding it. The record's\n   * `portHolder` names it. The supervisor starts the runtime the moment the port is free.\n   */\n  PORT_HELD_BY_FOREIGN_PROCESS = 'PORT_HELD_BY_FOREIGN_PROCESS',\n  /**\n   * STOPPED (#2149): an app-creator COMPANION's supervisor (`wildo-dev-companion-supervised`) saw it crash more times\n   * than its window tolerates, stopped restarting it, and exited. Unlike {@link CRASH_RESPAWN_EXHAUSTED}, no build\n   * starts it again: only restarting `wildo local dev` does, after the cause in its log is fixed. The record outlives\n   * its producer on purpose, which is how `wildo local dev-status` can say the companion is down and why.\n   */\n  CRASH_LOOP_GAVE_UP = 'CRASH_LOOP_GAVE_UP',\n  /**\n   * PAUSED (#3552): a dependency install is re-creating the application's `node_modules` (the build applied a\n   * composition scenario, or a person ran an install). A start now would boot against a half-installed tree, so the\n   * runtime is held, and a crash in this window is not counted against its budget. It starts again, with a fresh\n   * budget, the moment the install ends. See {@link LocalDevDependencyInstallRecord_Schema}.\n   */\n  DEPENDENCY_INSTALL_IN_FLIGHT = 'DEPENDENCY_INSTALL_IN_FLIGHT',\n}\n\n/**\n * The application-relative file, under the runtime-signals home, that says a dependency install is running in the\n * application, or when the last one ended (#3552). See {@link LocalDevDependencyInstallRecord_Schema}.\n */\nexport const LOCAL_DEV_DEPENDENCY_INSTALL_RECORD_FILE = 'dependency-install.json';\nexport const LOCAL_DEV_DEPENDENCY_INSTALL_RECORD_KIND = 'wildo.local-dev.dependency-install';\n\n/**\n * Where a dependency install stands, as every dev-loop reader of {@link LocalDevDependencyInstallRecord_Schema} judges it.\n */\nexport enum LocalDevDependencyInstallPhase {\n  /** No install has been recorded in this application. */\n  NONE = 'NONE',\n  /** An install is running: its writer is alive and its deadline has not passed. Nothing may start on the tree. */\n  IN_FLIGHT = 'IN_FLIGHT',\n  /**\n   * The install is over: it finished (successfully or not), its writer died without finishing, or it outlived its\n   * deadline. Everything that compiled or started before it ended read a tree that has since changed.\n   */\n  ENDED = 'ENDED',\n}\n\nconst isoTimestamp = z.string().refine((value) => Number.isFinite(Date.parse(value)), 'an ISO-8601 timestamp');\n\n/**\n * The process found listening on a port. That SOMETHING listens is established by connecting to it; who it is comes\n * from the operating system's tools (`lsof`, `ps`), which a host may lack, so every field but `port` may be unknown.\n */\nexport const LocalDevPortHolder_Schema = z.object({\n  port: z.number().int().positive(),\n  pid: z.number().int().positive().nullable(),\n  /** The holder's parent. `1` means it was re-parented to the init process: its own parent is gone (an orphan). */\n  ppid: z.number().int().nonnegative().nullable(),\n  /** When the holder started, as `ps` reports it. */\n  startedAt: z.string().nullable(),\n  /** The holder's working directory. */\n  cwd: z.string().nullable(),\n  /** The holder's command line, truncated. */\n  command: z.string().nullable(),\n});\nexport type LocalDevPortHolder = z.infer<typeof LocalDevPortHolder_Schema>;\n\n/**\n * One application package's compiler, as its observer last published it. Loose (unknown keys kept) because the framework\n * developer's observer writes further fields (its diagnostic, its producer kind) that no reader here depends on.\n */\nexport const LocalDevCompileObservation_Schema = z.looseObject({\n  kind: z.literal(LOCAL_DEV_COMPILE_OBSERVATION_KIND),\n  schemaVersion: z.literal(LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION),\n  producerPid: z.number().int().positive(),\n  /** The compiler process the producer owns, or null when none runs. */\n  childPid: z.number().int().positive().nullable(),\n  appRoot: z.string().min(1),\n  packageRoot: z.string().min(1),\n  packageName: z.string().min(1),\n  state: z.enum(LocalDevCompileState),\n  heartbeatAt: isoTimestamp,\n  updatedAt: isoTimestamp,\n  /** When the compiler last reported a compilation start. */\n  lastCompilationStartedAt: isoTimestamp.nullable(),\n  /** When a compilation last ended READY: emitted, post-processed and verified. */\n  lastSuccessfulCompileAt: isoTimestamp.nullable(),\n  lastFailureAt: isoTimestamp.nullable(),\n  lastErrorCount: z.number().int().nonnegative().nullable(),\n});\nexport type LocalDevCompileObservation = z.infer<typeof LocalDevCompileObservation_Schema>;\n\n/** One supervised runtime. Loose for the same reason as the compile observation. */\nexport const LocalDevSupervisorObservation_Schema = z.looseObject({\n  kind: z.literal(LOCAL_DEV_SUPERVISOR_OBSERVATION_KIND),\n  schemaVersion: z.literal(LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION),\n  producerPid: z.number().int().positive(),\n  label: z.string().min(1),\n  state: z.enum(LocalDevSupervisorState),\n  childPid: z.number().int().positive().nullable(),\n  /** When the current (or last) runtime child was started. */\n  childStartedAt: isoTimestamp.nullable().optional(),\n  /** A free-text reason (the monorepo supervisor's), or one of {@link LocalDevSupervisorBlocker}. */\n  blocker: z.string().nullable(),\n  /** Set with {@link LocalDevSupervisorBlocker.PORT_HELD_BY_FOREIGN_PROCESS}: the process that holds the port. */\n  portHolder: LocalDevPortHolder_Schema.nullable().optional(),\n  /**\n   * The file whose change asks this supervisor to restart its runtime (`<runtime-signals home>/<label>.signal`); `null`\n   * when the supervisor honours no such request. ABSENT from a writer that predates the field, which a reader treats as\n   * the conventional `<label>.signal` (the CLI does). Three writers set it: the monorepo's `runtime-supervisor.mjs`\n   * since #1031 and `wildo-dev-runtime serve` since #2134, each to its file (which is how `wildo secrets set` brings a\n   * changed key to a created application's running backend, minion or worker), and the app-creator companion's\n   * supervisor since #2149, to `null`: it honours no request, because the companion loads a changed key in place.\n   */\n  signalFilePath: z.string().min(1).nullable().optional(),\n  updatedAt: isoTimestamp,\n});\nexport type LocalDevSupervisorObservation = z.infer<typeof LocalDevSupervisorObservation_Schema>;\n\n/**\n * A dependency install in an application, as its installer records it (#3552).\n *\n * ## Why it exists\n *\n * `pnpm install` re-creates the application's `node_modules` while `wildo local dev` runs against it. Measured on\n * reference run 42666728304 (2026-11-09): the build's foundation step applied composition scenarios that added four\n * minions and a documentation site, and installed them (16 s). In that window every compile watcher compiled against a\n * half-installed tree (`TS2318 Cannot find global type 'Array'`, `TS6053 lib.dom.d.ts not found`) and nothing ever asked\n * it to compile again; the backend's readiness stayed blocked on those failures; every companion introspection worker\n * died on `Cannot find package 'zod'`; and the install re-created the virtual-store key of `@wildo-ai/framework-knowledge`\n * without its compiled knowledge tree, so `GET /api/companion/creation/questions` answered 500 for as long as the run\n * was watched. Nothing tied the install to the running stack.\n *\n * So the installer writes this record before the install (`finishedAt: null`) and again when it ends, and every dev-loop\n * process reads it: a runtime supervisor HOLDS its runtime while the install is in flight and does not count a crash\n * against its budget, then relaunches it (and, in a framework checkout, repairs the injected snapshots first); a\n * compile observer restarts a watcher whose last compile began before the install ended.\n *\n * ## Why a pid and a deadline rather than a heartbeat\n *\n * Every other in-flight signal here is a heartbeat refreshed from a timer. An install is often run SYNCHRONOUSLY\n * (`spawnSync` in the CLI), so no timer would beat during it. The writer's pid answers \"still running?\" and the\n * deadline bounds a writer that hangs, so a record can never hold the stack for good.\n *\n * ## Why it is never removed\n *\n * The finished record is what tells a watcher that started compiling before the install ended to compile again. It is a\n * cache in the sense of `one-source-of-truth.md`: deleting it costs one missed relaunch, never a fact.\n */\nexport const LocalDevDependencyInstallRecord_Schema = z.looseObject({\n  kind: z.literal(LOCAL_DEV_DEPENDENCY_INSTALL_RECORD_KIND),\n  schemaVersion: z.literal(LOCAL_DEV_RUNTIME_SIGNALS_PROTOCOL_VERSION),\n  /** The process running the install (the companion, or the CLI). */\n  pid: z.number().int().positive(),\n  startedAt: isoTimestamp,\n  /** Past this instant the install is treated as ended, whatever its writer says. */\n  deadlineAt: isoTimestamp,\n  /** When the install ended, or `null` while it runs. */\n  finishedAt: isoTimestamp.nullable(),\n  /** Whether it succeeded, or `null` while it runs. */\n  succeeded: z.boolean().nullable(),\n  /** Who installed, for a reader of the record: `foundation`, `wildo update`, … */\n  initiator: z.string().min(1),\n});\nexport type LocalDevDependencyInstallRecord = z.infer<typeof LocalDevDependencyInstallRecord_Schema>;\n"]}

package/dist/esm/runtime/runtime-topology.contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-topology.contracts.d.ts","sourceRoot":"","sources":["../../../../src/runtime/runtime-topology.contracts.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,oBAAY,uBAAuB;IACjC,qBAAqB,0BAA0B;IAC/C,iCAAiC,sCAAsC;IACvE,wBAAwB,6BAA6B;IACrD,qBAAqB,0BAA0B;IAC/C,QAAQ,aAAa;IACrB,aAAa,kBAAkB;CAChC;AAED;;;;;GAKG;AACH,oBAAY,0BAA0B;IACpC,qBAAqB,0BAAgD;IACrE,iCAAiC,sCAA4D;IAC7F,wBAAwB,6BAAmD;CAC5E;AAED,MAAM,WAAW,6BAA6B;IAC5C,WAAW,EAAE,mBAAmB,CAAC;IACjC,sBAAsB,EAAE,mBAAmB,CAAC;IAC5C;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,mBAAmB,CAAC;CACtC;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,6BAA6B,GACnC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CASrC;AAED,MAAM,WAAW,gCAAgC;IAC/C,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAAG,SAAS,CAAC;IACvE,OAAO,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAC1C,sBAAsB,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACzD,cAAc,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAClD;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,gCAAgC,GACtC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAerC;AAED,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAC7C,MAAM,CAER;AAED,wBAAgB,2BAA2B,CACzC,0BAA0B,EAAE,MAAM,GACjC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAsBrC"}
+{"version":3,"file":"runtime-topology.contracts.d.ts","sourceRoot":"","sources":["../../../src/runtime/runtime-topology.contracts.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,oBAAY,uBAAuB;IACjC,qBAAqB,0BAA0B;IAC/C,iCAAiC,sCAAsC;IACvE,wBAAwB,6BAA6B;IACrD,qBAAqB,0BAA0B;IAC/C,QAAQ,aAAa;IACrB,aAAa,kBAAkB;CAChC;AAED;;;;;GAKG;AACH,oBAAY,0BAA0B;IACpC,qBAAqB,0BAAgD;IACrE,iCAAiC,sCAA4D;IAC7F,wBAAwB,6BAAmD;CAC5E;AAED,MAAM,WAAW,6BAA6B;IAC5C,WAAW,EAAE,mBAAmB,CAAC;IACjC,sBAAsB,EAAE,mBAAmB,CAAC;IAC5C;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,mBAAmB,CAAC;CACtC;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,6BAA6B,GACnC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CASrC;AAED,MAAM,WAAW,gCAAgC;IAC/C,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAAG,SAAS,CAAC;IACvE,OAAO,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IAC1C,sBAAsB,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACzD,cAAc,CAAC,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAClD;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,gCAAgC,GACtC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAerC;AAED,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAC7C,MAAM,CAER;AAED,wBAAgB,2BAA2B,CACzC,0BAA0B,EAAE,MAAM,GACjC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAsBrC"}