omkit 0.8.1 → 0.8.2

package/CHANGELOG.md

@@ -46,6 +46,20 @@
 
 ### Fixed
 
+- **`typescript` moved from `devDependencies` to `dependencies`.** Three shipped modules import
+  it at runtime, and one of them — discovery — runs on every command, so an install that did not
+  already happen to have TypeScript nearby failed with `ERR_MODULE_NOT_FOUND` on `omkit ls`. It
+  went unnoticed because a monorepo hoists it into place.
+- **A node's log file no longer spells its name out as directories.** A node's id is
+  `<name>_<shortId>`, ids are joined with `/` into node paths, and those paths become log file
+  paths — so a name carrying its own separators was read as tree nesting. A `command` node is
+  named after its whole command line, and one watcher's log ended up nine directories deep, with
+  `docs`, `packages` and `tskb` as real folders inside the run. Names are now sanitised where the
+  id is made, which is the only place the two kinds of separator are still distinguishable, and
+  the name's contribution to an id is capped so a long command line cannot push a log path past
+  Windows' 260-character limit. Displayed names are untouched: nodes are shown by name, never by
+  id.
+
 - **One project, one `logs/` tree.** A run's record now lands under the project that owns the
   config, wherever the run was started from. It used to follow the working directory, and the
   frontends chose different ones: `omkit run` set it to the om file's own directory, so a project

package/dist/core/ExecutionTree.d.ts

@@ -124,8 +124,14 @@ export declare class ExecutionTree {
     private curatedArtifacts;
     /**
      * Absolute `.log` path for a node — root is `main.log`, children drop the `main/`
-     * prefix. Each id segment is sanitized so names with filesystem-illegal characters
-     * (e.g. `TSKB:root:watch:docs`) still produce a valid path.
+     * prefix. One directory level per ancestor, mirroring the tree.
+     *
+     * Every `/` here is a level, and that holds only because ids are sanitised where they are
+     * made (see `makeId`): a name that carried its own separators would be split here into
+     * levels it never had, and the run folder would grow directories spelling out a command's
+     * arguments. `fsSafe` stays as the second line of defence for anything that reaches a
+     * segment by another route; it cannot be the first, since by this point a separator from a
+     * name and a separator from the tree are the same character.
      */
     private logFile;
     private rawStreamPath;

package/dist/core/ExecutionTree.js

@@ -418,8 +418,14 @@ export class ExecutionTree {
     }
     /**
      * Absolute `.log` path for a node — root is `main.log`, children drop the `main/`
-     * prefix. Each id segment is sanitized so names with filesystem-illegal characters
-     * (e.g. `TSKB:root:watch:docs`) still produce a valid path.
+     * prefix. One directory level per ancestor, mirroring the tree.
+     *
+     * Every `/` here is a level, and that holds only because ids are sanitised where they are
+     * made (see `makeId`): a name that carried its own separators would be split here into
+     * levels it never had, and the run folder would grow directories spelling out a command's
+     * arguments. `fsSafe` stays as the second line of defence for anything that reaches a
+     * segment by another route; it cannot be the first, since by this point a separator from a
+     * name and a separator from the tree are the same character.
      */
     logFile(nodePath) {
         const rel = nodePath === "main" ? "main" : nodePath.slice("main/".length);

package/dist/foundation/ids.d.ts

@@ -5,6 +5,18 @@ export declare const shortId: (uuid: string) => string;
 /**
  * A node's id: `${name}_${shortId}` → `chromePage_9f3c`. The root passes its own
  * plain name (`main`) and skips this.
+ *
+ * The name is sanitised **here**, at the point the id is made, because an id is a path
+ * segment everywhere it is used: node paths join ids with `/`, and log file names are those
+ * paths mapped onto directories. A name carrying its own separators — `command("npx tsk
+ * ./docs/**\/*.tsx …")` is an ordinary one — is then indistinguishable from tree nesting, and
+ * one action's log went nine directories deep, spelling out the command's path arguments as
+ * real folders. Sanitising downstream cannot fix that: by the time a joined path is split
+ * back into segments, the separator that came from a name and the one that came from the tree
+ * are the same character.
+ *
+ * Uniqueness never depended on the name — that is the uuid's job — so truncating is safe and
+ * the readable form survives anyway: nodes are displayed by their `name`, not by their id.
  */
 export declare const makeId: (name: string, uuid: string) => string;
 /**

package/dist/foundation/ids.js

@@ -1,13 +1,34 @@
 import { createHash, randomUUID } from "node:crypto";
+import { fsSafe } from "./fsSafe.js";
 /** A fresh v4 uuid for a node. */
 export const newUuid = () => randomUUID();
 /** The short form used in ids/paths — first 8 hex of the uuid. */
 export const shortId = (uuid) => uuid.slice(0, 8);
+/**
+ * How much of a name an id keeps. A node's name is free text and can be long — a `command`
+ * node is named after its whole command line — while the id it seeds ends up inside a file
+ * path, where Windows still stops at 260 characters for the whole path.
+ */
+const MAX_NAME_IN_ID = 64;
 /**
  * A node's id: `${name}_${shortId}` → `chromePage_9f3c`. The root passes its own
  * plain name (`main`) and skips this.
+ *
+ * The name is sanitised **here**, at the point the id is made, because an id is a path
+ * segment everywhere it is used: node paths join ids with `/`, and log file names are those
+ * paths mapped onto directories. A name carrying its own separators — `command("npx tsk
+ * ./docs/**\/*.tsx …")` is an ordinary one — is then indistinguishable from tree nesting, and
+ * one action's log went nine directories deep, spelling out the command's path arguments as
+ * real folders. Sanitising downstream cannot fix that: by the time a joined path is split
+ * back into segments, the separator that came from a name and the one that came from the tree
+ * are the same character.
+ *
+ * Uniqueness never depended on the name — that is the uuid's job — so truncating is safe and
+ * the readable form survives anyway: nodes are displayed by their `name`, not by their id.
  */
-export const makeId = (name, uuid) => `${name}_${shortId(uuid)}`;
+export const makeId = (name, uuid) => `${clip(fsSafe(name))}_${shortId(uuid)}`;
+/** Trim to the cap, then drop any separator the cut left dangling. */
+const clip = (name) => name.slice(0, MAX_NAME_IN_ID).replace(/[-_.]+$/, "");
 /**
  * A run's stable identity: first 8 hex of sha256 over the defining file's absolute
  * path + the om name. Same file + name ⇒ same hash on every run; the same name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "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",
@@ -59,6 +59,7 @@
     "playwright-core": "^1.49.0",
     "react": "^19.2.8",
     "tsx": "4.23.1",
+    "typescript": "^5.9.3",
     "zod": "^4.4.3",
     "zx": "^8.8.5"
   },
@@ -66,7 +67,6 @@
     "@types/node": "^24",
     "@types/react": "^19.2.17",
     "ink-testing-library": "^4.0.0",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.9.3"
+    "rimraf": "^6.0.1"
   }
 }