omkit 0.8.22 → 0.8.23

package/dist/actions/command.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import path from "node:path";
-import { action } from "../core/action.js";
+import { action, launchedFrom } from "../core/action.js";
+import { callerSite } from "../foundation/callsite.js";
 import { debuggerFreeEnv, killTree, streamLines } from "../system/proc.js";
 /**
  * Build a zx tagged template that runs `cmd` verbatim.
@@ -24,19 +25,31 @@ export function commandName(cmdOrFile, options = {}) {
 export function command(cmdOrFile, options = {}) {
     const cwd = path.resolve(options.cwd ?? ".");
     const name = commandName(cmdOrFile, options);
+    // Built per call, so each launch below is in this file; record the user's line instead.
+    const site = callerSite();
+    // What the run record shows as this call's args. `env` is left out on purpose: it is a whole
+    // environment, secrets included, and the record is written to disk and into the report.
+    const shown = [
+        cmdOrFile,
+        {
+            ...(options.args && { args: options.args }),
+            ...(options.cwd && { cwd: options.cwd }),
+            ...(options.inheritDebugger && { inheritDebugger: true }),
+        },
+    ];
     // Shell command — the command string is the action (and proc) name.
     if (options.args === undefined) {
-        return action(name).run((ctx) => ctx.proc(cmdOrFile, {
+        return launchedFrom(site, () => action(name).run((ctx, ..._shown) => ctx.proc(cmdOrFile, {
             cwd,
             ...(options.env && { env: options.env }),
             ...(options.inheritDebugger && {
                 inheritDebugger: true,
             }),
-        })(verbatim(cmdOrFile)))();
+        })(verbatim(cmdOrFile)))(...shown));
     }
     // Direct executable — the file plus its args form the action name.
     const args = options.args;
-    return action(name).run(async (ctx) => {
+    return launchedFrom(site, () => action(name).run(async (ctx, ..._shown) => {
         const inherit = options.inheritDebugger;
         const env = inherit
             ? (options.env ?? process.env)
@@ -83,5 +96,5 @@ export function command(cmdOrFile, options = {}) {
             finished = true;
             ctx.signal.removeEventListener("abort", onAbort);
         }
-    })();
+    })(...shown));
 }

package/dist/actions/poll-until.js

@@ -1,5 +1,6 @@
 import { setTimeout as sleep } from "node:timers/promises";
-import { action } from "../core/action.js";
+import { action, launchedFrom } from "../core/action.js";
+import { callerSite } from "../foundation/callsite.js";
 /**
  * Gate: calls `predicate` every `intervalMs` until it returns something other than `false`,
  * `null` or `undefined`, and resolves with that value — so it can find a thing as well as wait
@@ -9,7 +10,11 @@ import { action } from "../core/action.js";
  */
 export function pollUntil(description, predicate, options = {}) {
     const { intervalMs = 200, timeoutMs = 30_000 } = options;
-    return action(description).run(async ({ signal }) => {
+    // Built per call, so the launch below is in this file; record the user's line instead.
+    const site = callerSite();
+    return launchedFrom(site, () => 
+    // The call's own arguments go through the launch, so the run record shows them as args.
+    action(description).run(async ({ signal }, ..._call) => {
         const deadline = Date.now() + timeoutMs;
         let attempts = 0;
         for (;;) {
@@ -26,5 +31,5 @@ export function pollUntil(description, predicate, options = {}) {
             }
             await sleep(Math.min(intervalMs, remaining), undefined, { signal });
         }
-    })();
+    })(description, predicate, options));
 }

package/dist/core/action.d.ts

@@ -1,4 +1,12 @@
 import type { ActionBuilderEvents, NoEvents } from "./types.ts";
+/**
+ * Run `launch` (which must launch exactly one action, synchronously) with `site` recorded as
+ * that launch's `calledAt`. For batteries that build their action per call inside a factory
+ * (`command`, `pollUntil`): the launch then happens in omkit's own file, so the frame the
+ * launch would record is the factory, not the user's line. The factory captures its caller
+ * with `callerSite()` and hands it over here.
+ */
+export declare function launchedFrom<T>(site: string | undefined, launch: () => T): T;
 /**
  * Define an action. Provide the impl via `.run(…)`, optionally after declaring
  * metadata (`.describe(…)`), events (`.emits<…>()`), an imperative handle

package/dist/core/action.js

@@ -2,6 +2,29 @@ import { ExecutionTree } from "./ExecutionTree.js";
 import { callerSite } from "../foundation/callsite.js";
 import { describeSchema } from "./discovery-mode.js";
 import { formatIssues } from "./args.js";
+/** A call site handed over by {@link launchedFrom}, taken by the very next launch. */
+let handedSite;
+const takeHandedSite = () => {
+    const site = handedSite;
+    handedSite = undefined;
+    return site;
+};
+/**
+ * Run `launch` (which must launch exactly one action, synchronously) with `site` recorded as
+ * that launch's `calledAt`. For batteries that build their action per call inside a factory
+ * (`command`, `pollUntil`): the launch then happens in omkit's own file, so the frame the
+ * launch would record is the factory, not the user's line. The factory captures its caller
+ * with `callerSite()` and hands it over here.
+ */
+export function launchedFrom(site, launch) {
+    handedSite = site;
+    try {
+        return launch();
+    }
+    finally {
+        handedSite = undefined;
+    }
+}
 /**
  * The builder returned by `action(name)`: declare metadata (`.describe(…)`), events
  * (`.emits<…>()`), an imperative handle (`.ref<…>()`), and/or pin the args type
@@ -56,7 +79,7 @@ class Builder {
         const exec = body;
         const create = (...args) => {
             // where this launch was written — for a battery, the user's call rather than its definition
-            const calledAt = callerSite();
+            const calledAt = takeHandedSite() ?? callerSite();
             const spec = { name, args, tags: [], body: exec, definedAt, calledAt, meta };
             return ExecutionTree.require().launch(spec);
         };
@@ -124,7 +147,7 @@ class ArgsBuilder {
         const exec = body;
         const create = (...args) => {
             // where this launch was written — for a battery, the user's call rather than its definition
-            const calledAt = callerSite();
+            const calledAt = takeHandedSite() ?? callerSite();
             const spec = { name, args, tags: [], body: exec, definedAt, calledAt, meta };
             return ExecutionTree.require().launch(spec);
         };

package/dist/output/writers/report/report.js

@@ -752,7 +752,8 @@
         const need = text.length * 6.6 + 14;
         const inside = w >= need;
         const clipX = Math.max(x0, 0);
-        const outside = !inside && w <= 60;
+        // outside, too, when inside would cut it to a stub (`port =…`): a call label needs room
+        const outside = !inside && w < 16 * 6.6 + 14;
         const shown = inside || outside ? text : truncate(text, (w - 14) / 6.6);
         const tw = shown.length * 6.6;
         // an outside label that would run off the chart hangs left of its bar instead

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.8.22",
+  "version": "0.8.23",
   "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",