omkit 0.4.0 → 0.4.1

package/dist/cli/client/discovery.d.ts

@@ -1,7 +1,8 @@
 import type { Registry } from "./registry.ts";
 /**
  * Statically scan the project described by `tsconfigPath` for runnable oms and inspectable
- * actions. Never throws for user-code problems — type errors become `warnings`, and whatever
- * parsed is still returned (so an editor-in-progress project stays useful).
+ * actions. Type errors in the user's oms/actions degrade to `warnings` (an editor-in-progress
+ * project stays useful), but a **fatal config problem** — a missing, unparseable, or invalid
+ * tsconfig — throws, so the CLI crashes visibly instead of silently returning an empty project.
  */
 export declare function discover(tsconfigPath: string): Registry;

package/dist/cli/client/discovery.js

@@ -2,22 +2,16 @@ import ts from "typescript";
 import path from "node:path";
 /**
  * Statically scan the project described by `tsconfigPath` for runnable oms and inspectable
- * actions. Never throws for user-code problems — type errors become `warnings`, and whatever
- * parsed is still returned (so an editor-in-progress project stays useful).
+ * actions. Type errors in the user's oms/actions degrade to `warnings` (an editor-in-progress
+ * project stays useful), but a **fatal config problem** — a missing, unparseable, or invalid
+ * tsconfig — throws, so the CLI crashes visibly instead of silently returning an empty project.
  */
 export function discover(tsconfigPath) {
     const oms = [];
     const actions = [];
     const warnings = [];
-    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
-    if (configFile.error) {
-        warnings.push(ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
-        return { oms, actions, warnings };
-    }
-    // Resolve to an absolute base so `parsed.fileNames` are absolute. Otherwise root files stay
-    // relative while imported files (e.g. an action pulled in by an om) resolve to absolute paths,
-    // and the two never match in `fileSet`.
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.resolve(path.dirname(tsconfigPath)));
+    const { parsed, warnings: configWarnings } = loadProject(tsconfigPath);
+    warnings.push(...configWarnings);
     const program = ts.createProgram({
         rootNames: parsed.fileNames,
         options: { ...parsed.options, noEmit: true },
@@ -62,6 +56,28 @@ export function discover(tsconfigPath) {
     }
     return { oms, actions, warnings };
 }
+/**
+ * Load and validate the tsconfig, throwing on a fatal config problem — a missing/unparseable file,
+ * or a config-level error (bad compilerOptions, an unresolvable `extends`). The benign "no inputs
+ * found" (TS18003) is not fatal: an empty-but-valid project comes back as a warning instead.
+ *
+ * Parses against an absolute base dir so `parsed.fileNames` are absolute — otherwise root files
+ * stay relative while imported files (an action pulled in by an om) resolve absolute, and the two
+ * never match in the caller's `fileSet`.
+ */
+function loadProject(tsconfigPath) {
+    const flatten = (d) => ts.flattenDiagnosticMessageText(d.messageText, "\n");
+    const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    if (configFile.error)
+        throw new Error(`could not read ${tsconfigPath}: ${flatten(configFile.error)}`);
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.resolve(path.dirname(tsconfigPath)));
+    const fatal = parsed.errors.filter((e) => e.category === ts.DiagnosticCategory.Error && e.code !== 18003);
+    if (fatal.length) {
+        throw new Error(`invalid ${tsconfigPath}:\n${fatal.map((e) => `  ${flatten(e)}`).join("\n")}`);
+    }
+    const warnings = parsed.errors.filter((e) => e.code === 18003).map(flatten);
+    return { parsed, warnings };
+}
 /** Collect the local names bound to om/step/action from `import … from "omkit"`. */
 function omkitImports(sf) {
     const names = {};

package/dist/cli/commands/ui.d.ts

@@ -3,5 +3,9 @@ import type { OmkitClient } from "../client/index.ts";
  * Render the interactive Ink app. Ink's own Ctrl+C handling is disabled so the app can tear the
  * run down gracefully first; the final verdict + run-folder path are printed here, after Ink
  * unmounts (it erases its own frame), so the pointer to the on-disk record survives on screen.
+ *
+ * Discovery runs first, before Ink takes the terminal: a fatal config problem throws here and the
+ * bin's error boundary turns it into a clean crash rather than an empty list. Non-fatal warnings
+ * are printed so they aren't lost behind the UI.
  */
-export declare function launchUi(client: OmkitClient): void;
+export declare function launchUi(client: OmkitClient): Promise<void>;

package/dist/cli/commands/ui.js

@@ -5,10 +5,17 @@ import { App } from "../ui/app.js";
  * Render the interactive Ink app. Ink's own Ctrl+C handling is disabled so the app can tear the
  * run down gracefully first; the final verdict + run-folder path are printed here, after Ink
  * unmounts (it erases its own frame), so the pointer to the on-disk record survives on screen.
+ *
+ * Discovery runs first, before Ink takes the terminal: a fatal config problem throws here and the
+ * bin's error boundary turns it into a clean crash rather than an empty list. Non-fatal warnings
+ * are printed so they aren't lost behind the UI.
  */
-export function launchUi(client) {
+export async function launchUi(client) {
+    const registry = await client.discover();
+    for (const w of registry.warnings)
+        process.stderr.write(`omkit: warning: ${w}\n`);
     let finalVerdict;
-    const app = render(_jsx(App, { client: client, onExit: (v) => (finalVerdict = v) }), {
+    const app = render(_jsx(App, { client: client, oms: registry.oms, onExit: (v) => (finalVerdict = v) }), {
         exitOnCtrlC: false,
     });
     void app.waitUntilExit().then(() => {

package/dist/cli/index.js

@@ -51,7 +51,7 @@ async function main() {
         // A bare `omkit` lands here too, since `run` is the default command.
         if (!cli.target) {
             const { launchUi } = await import("./commands/ui.js");
-            launchUi(client);
+            await launchUi(client);
             return;
         }
         const { resolveOm } = await import("./commands/run.js");
@@ -87,5 +87,24 @@ function isEntryPoint() {
         return false;
     }
 }
-if (isEntryPoint())
-    void main();
+/** Print a fatal error to stderr in one consistent shape, just before the process exits non-zero. */
+function reportFatal(err) {
+    const detail = err instanceof Error ? (err.stack ?? err.message) : String(err);
+    process.stderr.write(`\nomkit: ${detail}\n`);
+}
+if (isEntryPoint()) {
+    // Nothing should fail silently. A fatal anywhere — a bad config, an uncaught throw, or a rejected
+    // promise in the interactive app — prints and crashes the CLI with a non-zero exit code.
+    process.on("uncaughtException", (err) => {
+        reportFatal(err);
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (err) => {
+        reportFatal(err);
+        process.exit(1);
+    });
+    main().catch((err) => {
+        reportFatal(err);
+        process.exit(1);
+    });
+}

package/dist/cli/ui/app.d.ts

@@ -1,9 +1,12 @@
 import { type ReactElement } from "react";
 import type { OmkitClient, Verdict } from "../client/types.ts";
+import type { DiscoveredOm } from "../client/registry.ts";
 /** The interactive app: discover → list/search → run → live milestones + prompts. */
-export declare function App({ client, onExit, }: {
+export declare function App({ client, onExit, oms: initialOms, }: {
     client: OmkitClient;
     /** Called with the run's verdict (if any) just before Ink unmounts, so the caller can print
      *  a durable summary — Ink erases its own frame on exit. */
     onExit?: (verdict: Verdict | undefined) => void;
+    /** Oms discovered by the caller (pre-flight). When given, the app skips its own discovery. */
+    oms?: DiscoveredOm[];
 }): ReactElement;

package/dist/cli/ui/app.js

@@ -6,9 +6,9 @@ import { OmList } from "./views/OmList.js";
 import { RunView } from "./views/RunView.js";
 import { Spinner } from "./Spinner.js";
 /** The interactive app: discover → list/search → run → live milestones + prompts. */
-export function App({ client, onExit, }) {
+export function App({ client, onExit, oms: initialOms, }) {
     const { exit } = useApp();
-    const [oms, setOms] = useState([]);
+    const [oms, setOms] = useState(initialOms ?? []);
     const [session, setSession] = useState(null);
     const [lines, setLines] = useState([]);
     const [prompt, setPrompt] = useState();
@@ -19,6 +19,8 @@ export function App({ client, onExit, }) {
     const verdictRef = useRef(undefined);
     const tearingRef = useRef(false);
     useEffect(() => {
+        if (initialOms)
+            return; // provided by the caller's pre-flight discovery
         let live = true;
         void client.discover().then((r) => {
             if (live)
@@ -27,7 +29,7 @@ export function App({ client, onExit, }) {
         return () => {
             live = false;
         };
-    }, [client]);
+    }, [client, initialOms]);
     const run = (om) => {
         const s = client.run(om.file);
         sessionRef.current = s;

package/dist/core/ActionRun.js

@@ -131,8 +131,13 @@ export class ActionRun {
                 if (win())
                     resolve(undefined);
             }, (error) => {
-                if (win())
-                    key === "error" ? resolve(error) : reject(error);
+                if (!win())
+                    return;
+                // Awaiting the `error` event hands back the error; any other gate rejects on failure.
+                if (key === "error")
+                    resolve(error);
+                else
+                    reject(error);
             });
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "A tiny runtime for developer workflows: typed actions that pass runtime capabilities and emit typed events, under one run and one shared log. The operational/runtime layer to tskb's knowledge layer.",
   "type": "module",
   "main": "./dist/index.js",