@lostgradient/weft 0.14.0 → 0.16.0

package/README.md

@@ -1,6 +1,6 @@
 # Weft
 
-A Bun-native durable execution engine. Current release: `0.14.0`.
+A Bun-native durable execution engine. Current release: `0.16.0`.
 
 Install the library from npm as `@lostgradient/weft`:
 
@@ -43,14 +43,9 @@ Weft is a ground-up rethink: what would durable execution look like if you desig
 
 ## Stability Tiers
 
-Weft is still pre-1.0. The table below is the current adoption guidance, not a permanent compatibility guarantee. Surfaces marked **candidate-stable** are expected to carry the 1.0 support promise if the [Tier-0 Behavioral Contract](documentation/architecture/tier-0-behavioral-contract.md) does not force a public-shape change. Tier-0 work may still add error codes, duplicate-response shapes, or storage-capability failures before those surfaces graduate.
+Weft is pre-1.0. The [breaking-change policy](documentation/contributing/breaking-changes.md#stability-tiers) owns the current candidate-stable and experimental surface inventory; feature guides state local context without maintaining a second list.
 
-| Tier                          | Surfaces                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | What to expect                                                                                                             |
-| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------- |
-| Candidate-stable, provisional | Engine core, [`TestEngine`](documentation/guides/testing.md), Bun SQLite, Node SQLite, LMDB, [`RemoteWorker`](documentation/guides/remote-workers.md), [`serve()`](documentation/guides/server.md) and `/v1` REST, source/binary CLI commands `serve`, `doctor`, `version`, `--version`, and `-v`, exported public error codes                                                                                                                                                                                                                   | Suitable for serious trials. Pin the package version and read release notes before upgrading until the 1.0 contract lands. |
-| Experimental                  | [Browser runtime](documentation/guides/service-worker.md), [MCP](documentation/reference/api-server.md#mcp-server), IndexedDB, WebExtension, HTTP and compressed storage, Turso pending conformance proof, CLI commands beyond `serve`, `doctor`, `version`, `--version`, and `-v` when running Weft from source or a standalone binary, [OpenTelemetry](documentation/guides/observability.md) metric names, externally supplied dashboard mounting, [`ctx.step()`](documentation/guides/workflows.md#getting-started-without-generators) sugar | API shape, storage guarantees, diagnostics, or compatibility behavior may change without a deprecation window before 1.0.  |
-
-If a surface is not named here, treat it as experimental. Stability is about compatibility and operational guarantees; it is not a statement that every candidate-stable surface is appropriate for every deployment.
+Candidate-stable surfaces are suitable for serious trials, but the 1.0 compatibility promise is not final until the Tier-0 work is complete. Surfaces not named in the canonical inventory are experimental by default.
 
 The public path to 1.0 is tracked in the [roadmap to 1.0](documentation/roadmap-to-1.0.md). The 1.0 compatibility promise will apply to the stable tier only; experimental surfaces may continue changing until they graduate.
 

package/dist/alerting/alert-manager.d.ts

@@ -40,5 +40,7 @@ export declare class AlertManager implements Disposable {
     tick(): void;
     /** Get current state of all alert rules (for debugging/testing). */
     get states(): readonly AlertState[];
+    /** Get the alert rules that are currently firing. */
+    get activeStates(): readonly AlertState[];
     [Symbol.dispose](): void;
 }

package/dist/alerting/alert-manager.js

@@ -155,6 +155,9 @@ export class AlertManager {
   get states() {
     return this.#states;
   }
+  get activeStates() {
+    return this.#states.filter((state) => state.status === "firing");
+  }
   [Symbol.dispose]() {
     if (this.#tickInterval !== null) {
       clearInterval(this.#tickInterval);

package/dist/cli/api.js

@@ -1,6 +1,7 @@
 import { createLiveOperationRegistry } from "../server/rest-bindings.js";
 import { findNearestCandidate } from "./command-suggestions.js";
 import snapshotData from "./generated/operation-catalog.snapshot.json";
+import { loadJsonInput } from "./json-input.js";
 import { sendJsonRpcRequest } from "./json-rpc-client.js";
 const snapshot = snapshotData, operationByName = new Map(snapshot.operations.map((operation) => [operation.name, operation]));
 export async function executeApi(command) {
@@ -107,25 +108,10 @@ function formatOperationDescription(operation) {
 `);
 }
 async function readInput(command) {
-  if (command.input !== void 0)
-    return parseInput(command.input);
-  if (command.inputFile !== void 0) {
-    if (command.inputFile === "-")
-      return parseInput(await Bun.stdin.text());
-    const file = Bun.file(command.inputFile);
-    if (!await file.exists())
-      return { ok: !1, output: usageError(`api: input file not found: ${command.inputFile}`) };
-    return parseInput(await file.text());
-  }
-  return { ok: !0, value: {} };
-}
-function parseInput(source) {
-  try {
-    return { ok: !0, value: JSON.parse(source) };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { ok: !1, output: usageError(`api: invalid JSON input: ${message}`) };
-  }
+  const result = await loadJsonInput(command.input, command.inputFile);
+  if (!result.ok)
+    return { ok: !1, output: usageError(`api: ${result.error.message}`) };
+  return { ok: !0, value: result.value === void 0 ? {} : result.value };
 }
 function validateInput(operationName, input) {
   const operation = createLiveOperationRegistry().get(operationName);

package/dist/cli/console.d.ts

@@ -0,0 +1,12 @@
+import type { DashboardAssets, DashboardRouteTarget } from '../server/index.ts';
+export interface ConsoleMount {
+    dashboard: DashboardRouteTarget;
+    dashboardAssets: DashboardAssets;
+}
+export interface ConsoleModuleLoaderOptions {
+    cwd?: string;
+    resolveModule?: (specifier: string, cwd: string) => string;
+    importModule?: (url: string) => Promise<unknown>;
+}
+/** Resolve and load the optional console from the CLI user's environment. */
+export declare function loadConsoleMount(options?: ConsoleModuleLoaderOptions): Promise<ConsoleMount>;

package/dist/cli/console.js

@@ -0,0 +1,62 @@
+import { statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const CONSOLE_PACKAGE_NAME = "@lostgradient/weft-console";
+function defaultImportModule(url) {
+  return import(url);
+}
+function isDashboardRouteTarget(value) {
+  return typeof value === "function" || typeof value === "string" || value instanceof Response;
+}
+function isConsoleModule(value) {
+  return typeof value === "object" && value !== null;
+}
+function consoleError(message) {
+  return Error(`--console ${message}`);
+}
+function resolveConsoleEntry(cwd, resolveModule) {
+  try {
+    return resolveModule(CONSOLE_PACKAGE_NAME, cwd);
+  } catch {
+    throw consoleError(`requires ${CONSOLE_PACKAGE_NAME}. Install it in the CLI project: bun add ${CONSOLE_PACKAGE_NAME}`);
+  }
+}
+async function importConsoleModule(resolvedEntry, importModule) {
+  try {
+    const loaded = await importModule(pathToFileURL(resolvedEntry).href);
+    if (!isConsoleModule(loaded))
+      throw Error("module is not an object");
+    return loaded;
+  } catch {
+    throw consoleError(`could not load ${CONSOLE_PACKAGE_NAME}; reinstall or update it, then retry, or remove --console`);
+  }
+}
+function loadDashboard(module) {
+  if (typeof module.weftConsole !== "function")
+    throw consoleError(`${CONSOLE_PACKAGE_NAME} must export a weftConsole() function; update the package or remove --console`);
+  try {
+    const dashboard = module.weftConsole();
+    if (!isDashboardRouteTarget(dashboard))
+      throw Error("invalid dashboard route target");
+    return dashboard;
+  } catch {
+    throw consoleError(`${CONSOLE_PACKAGE_NAME} weftConsole() failed; reinstall or update it, then retry, or remove --console`);
+  }
+}
+function resolveConsoleAssets(resolvedEntry) {
+  const directory = join(dirname(fileURLToPath(pathToFileURL(resolvedEntry))), "assets");
+  try {
+    if (!statSync(directory).isDirectory())
+      throw Error("not a directory");
+  } catch {
+    throw consoleError(`${CONSOLE_PACKAGE_NAME} is missing its built assets; reinstall or update it, then retry, or remove --console`);
+  }
+  return { prefix: "/assets", directory };
+}
+export async function loadConsoleMount(options = {}) {
+  const cwd = options.cwd ?? process.cwd(), resolveModule = options.resolveModule ?? Bun.resolveSync, importModule = options.importModule ?? defaultImportModule, resolvedEntry = resolveConsoleEntry(cwd, resolveModule), module = await importConsoleModule(resolvedEntry, importModule);
+  return {
+    dashboard: loadDashboard(module),
+    dashboardAssets: resolveConsoleAssets(resolvedEntry)
+  };
+}