@w6w/embed 0.1.1 → 0.2.0

package/dist/lib/recent-activity.d.ts

@@ -0,0 +1,128 @@
+import { DashboardStats } from '../repos/dashboard.ts';
+/** One row of the dashboard's "Recent activity" list — the pinned wire shape
+ *  (`DashboardStats["recent"][number]`, widened by T1.1.2). */
+export type RecentActivityEntry = DashboardStats["recent"][number];
+/** Human labels for the ledger `kind` domain (mirrors the server's `run_log.kind`). */
+export declare const KIND_LABELS: Record<string, string>;
+/**
+ * The seven ledger kinds this module KNOWS — the arms the two `Record`s below
+ * name explicitly, so a kind added to `run_log.kind` is a compile error here
+ * rather than a row silently rendering as another kind (the same reasoning
+ * `RESOURCE_DESCRIPTORS` gives for its total `Record`).
+ */
+export type ActivityKind = "workflow" | "workflow_step" | "connection_test" | "node_debug" | "function" | "endpoint" | "action";
+/**
+ * The label for a ledger kind. An unrecognised kind falls back to the raw value:
+ * `kind` is a wire field and a client can be older than the server that answered
+ * it — a raw `"schedule"` reads better than a blank row.
+ */
+export declare function kindLabel(kind: string): string;
+/** Which tile a row renders as: today's row, or one of the three named ones. */
+export type TileVariant = "base" | "function" | "workflow" | "workflow_step";
+/**
+ * The kind→variant table. Only the kinds that HAVE a name (or, for a step, an
+ * id) to link to move off the base tile — `workflow_step` joined them in R-1,
+ * titled `{workflow name} - {step id}` (R-2); endpoint/action rows keep
+ * today's look (DC-6). Every other arm is spelled out rather than left to a
+ * default, so dropping or adding a kind is a visible edit here.
+ */
+export declare const TILE_VARIANT: Record<ActivityKind, TileVariant>;
+/**
+ * The tile a row renders as — the ONE dispatcher `RecentActivityTile` reads.
+ * An unknown kind is the base tile, never a missing render: the same
+ * older-client-than-server case {@link kindLabel} answers.
+ */
+export declare function tileVariantFor(kind: string): TileVariant;
+/**
+ * The list rows the two name maps are built from, structurally: the SDK's
+ * `FunctionSummary`/`WorkflowSummary` satisfy these without a cast, and a
+ * fixture in the unit test needs no SDK round trip.
+ */
+export interface FunctionNameRow {
+    id: string;
+    /** The callable name; `null` on a `WorkflowSummary`, never on a Function. */
+    key?: string | null;
+    displayName?: string | null;
+}
+export interface WorkflowNameRow {
+    id: string;
+    /** The stable slug; every Workflow has one. */
+    name?: string | null;
+    displayName?: string | null;
+}
+/** `id → display label` for the two kinds whose rows carry a name. */
+export interface ActivityNameMaps {
+    functions: ReadonlyMap<string, string>;
+    workflows: ReadonlyMap<string, string>;
+}
+/**
+ * Build the two `id → name` maps a tile resolves its title through.
+ *
+ * Both lists are the ACCOUNT-scoped reads `useFunctionsQuery()`/
+ * `useWorkflowsQuery()` already make (DC-1) — the dashboard's own
+ * `recentForAccount` is account-wide, so a project-narrowed list here would
+ * label most rows with a raw `fn_…`/`wf_…` id. A missing list (its query still
+ * loading, or failed) is an empty map: the tile then falls back to today's
+ * title rather than blocking the row.
+ *
+ * The label is `displayName || key` for a Function and `displayName || name`
+ * for a Workflow (the server's own fallback order). A row carrying neither is
+ * left OUT of the map rather than mapped to `""`: "in the map" then means
+ * exactly "there is a name to link to", which is the rule
+ * {@link resolveTileTitle} reads.
+ */
+export declare function buildNameMaps(functions?: readonly FunctionNameRow[], workflows?: readonly WorkflowNameRow[]): ActivityNameMaps;
+/** The resource a tile title links to — a studio route kind plus its id. */
+export interface ActivityTileTarget {
+    kind: "function" | "workflow";
+    id: string;
+}
+export interface ResolvedTileTitle {
+    /** What the title reads: the resolved name, else today's `summary`/kind label. */
+    text: string;
+    /** Where it links, or `null` for a plain, unlinked title. */
+    target: ActivityTileTarget | null;
+}
+/**
+ * The title of one row — the name-as-link rule.
+ *
+ * A `function`/`workflow` row links ONLY when its id resolves to a name in the
+ * maps above. Every other case — a base-variant kind, a `null` id, or an id the
+ * list did not carry — is today's plain title (`summary ?? kindLabel(kind)`)
+ * with no target, so a failed or still-loading name lookup degrades to the id
+ * the row already shows instead of a dead link.
+ *
+ * A `workflow_step` row (R-1) is the same rule plus the step's own id: a
+ * resolved workflow name makes the link, exactly as it does on a `workflow`
+ * row, and the title reads `{workflow name} - {step id}` — a spaced ASCII
+ * hyphen-minus, R-2. The step id IS the step's name — `core/rfcs/workflow.md`'s
+ * `id` is its machine name and the editor's "Rename step" rewrites exactly that
+ * — so no definition is fetched and no `notes` is read. When the workflow does
+ * NOT resolve the left side is the workflow id itself, then the row's `summary`,
+ * then `"Unknown workflow"` — never the kind label, since a title reading
+ * "Workflow step" is exactly what R-1 rejected — and the target is `null`: a
+ * link only when the name resolved. An absent `stepId` leaves the title as just
+ * that left side.
+ */
+export declare function resolveTileTitle(entry: RecentActivityEntry, names: ActivityNameMaps): ResolvedTileTitle;
+/**
+ * A row's timestamp in LOCAL time as `YYYY-MM-DD HH:mm:ss`, 24-hour and
+ * zero-padded — the exact, sortable, unambiguous stamp a ledger row wants.
+ *
+ * `toLocaleString` is deliberately NOT reused (what this replaces): its output
+ * is locale-dependent ("Jan 5, 7:08 AM", no seconds) and so unreadable as a
+ * timestamp. The `get*` accessors, never the `getUTC*` ones, are what make this
+ * the viewer's own wall clock. An unparseable value is returned unchanged —
+ * better the raw string than `NaN-NaN-NaN`.
+ */
+export declare function formatTimestamp(iso: string): string;
+/**
+ * A duration in milliseconds, or `null` when there is nothing to show.
+ *
+ * Three magnitudes, three units, so the number stays readable at every scale:
+ * sub-second in ms, sub-minute in seconds to one decimal, and minutes+seconds
+ * above that. `null`/`undefined`/negative/non-finite are all "unknown" — the
+ * ledger writes none of them on purpose, and a tile that renders `NaN s` is
+ * worse than one that renders nothing (DC-2: historical rows simply omit it).
+ */
+export declare function formatDuration(ms: number | null | undefined): string | null;

package/dist/lib/target-fields.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Pure helpers shared by `TargetSelector`'s three arms (rfcs/endpoint.md
+ * :339-347 — `EndpointTarget = CallableRef | ActionTarget`) and by
+ * `EndpointsPage`'s save gate.
+ *
+ * Pure and testable by design, mirroring `workflow-validity.ts`'s shape:
+ * `@w6w/ui`'s `package.json` `exports["."]` resolves to raw `./src/index.ts`,
+ * which re-exports `.tsx` files, so `node --test` throws
+ * `ERR_UNKNOWN_FILE_EXTENSION` the moment anything here imports `@w6w/ui` or
+ * `@w6w/ui/flow` — even type-only. So this module declares its own local
+ * structural (`*Like`) types instead of importing the real ones from
+ * `../api/types.ts`, and `isTriggerApp`/`asFieldDefs` (the workflow arm's only
+ * dependency on `@w6w/ui/flow`) are **caller-injected** — `TargetSelector.tsx`
+ * (unaffected by the JSX constraint) imports the real ones and passes them in.
+ */
+/** The four arms `EndpointTarget` can take; a Function's `impl` takes the
+ *  first three (D-8) — `"endpoint"` is alias-only, never legal for `Fn.impl`. */
+export type TargetKind = "action" | "function" | "workflow" | "endpoint";
+/** The `action` arm — same `{ uses, with }` shape a Function's `impl` carries. */
+export interface ActionTargetLike {
+    kind: "action";
+    uses: {
+        app: string;
+        action: string;
+        connection?: string | null;
+    };
+    with?: Record<string, unknown>;
+}
+/** The `function`/`workflow` arms — a bare ref, one hop to a CallableRef. */
+export type CallableTargetLike = {
+    kind: "function";
+    function: string;
+} | {
+    kind: "workflow";
+    workflow: string;
+};
+/** The `endpoint` arm — a bare ref to another Endpoint. Alias-only (plan.md
+ *  §2a): legal for `AliasDef.target`, never for an Endpoint's own `target`
+ *  (the server refuses it — `admin/endpoints.ts`'s `validateDefinition`). */
+export interface EndpointRefTargetLike {
+    kind: "endpoint";
+    endpoint: string;
+}
+/** The full local mirror of `EndpointTarget` this module operates on. */
+export type TargetLike = ActionTargetLike | CallableTargetLike | EndpointRefTargetLike;
+/**
+ * The action arm of a Function's `impl` — today's `FunctionImplLike` shape,
+ * plus the two fields D-8 adds: `kind?: "action"` (absent means "action",
+ * unchanged for every Function stored before the union existed) and
+ * `outputMap?` (mirrors the action arm's own adapter-out pass, already on
+ * `FnActionImpl`/`FunctionActionImpl`).
+ */
+export interface ActionImplLike {
+    kind?: "action";
+    uses: {
+        app: string;
+        action: string;
+        connection?: string | null;
+    };
+    with?: Record<string, unknown>;
+    outputMap?: Record<string, unknown>;
+}
+/**
+ * A Function's `impl` (D-8, `rfcs/function.md` as amended by TC2) — bound to
+ * one app Action, or to another Function/Workflow via `CallableTargetLike`
+ * (reused verbatim, never a fourth local mirror), intersected with the same
+ * `with`/`outputMap` adapter pair the action arm carries — field-for-field
+ * `FnCallableImpl = CallableRef & {with?; outputMap?}` (TC2's pinned type).
+ */
+export type FunctionImplLike = ActionImplLike | (CallableTargetLike & {
+    with?: Record<string, unknown>;
+    outputMap?: Record<string, unknown>;
+});
+/** A declared action/function param, just enough of it for the projector. */
+export interface ParamLike {
+    key: string;
+    label?: string;
+    type?: string;
+    required?: boolean;
+    default?: unknown;
+    showIf?: ShowIfPredicate;
+}
+/** Visibility predicate — mirroring ActionParam.showIf from @w6w/ui. */
+export interface ShowIfPredicate {
+    field: string;
+    equals?: unknown;
+    in?: unknown[];
+    notIn?: unknown[];
+    truthy?: boolean;
+}
+/** One field of a manual/webhook trigger's `with.fields` (`@w6w/ui/flow`'s `TriggerFieldDef`). */
+export interface TriggerFieldDefLike {
+    key?: string;
+    type?: string;
+    default?: unknown;
+    required?: boolean;
+}
+/** A workflow graph step, just enough of it for the trigger-field union (A6). */
+export interface WorkflowStepLike {
+    uses?: {
+        app?: string;
+    };
+    with?: Record<string, unknown>;
+}
+/** A workflow definition, just enough of it for the trigger-field union. */
+export interface WorkflowLike {
+    steps?: unknown;
+}
+/** Everything `fieldsFromWorkflow` needs from `@w6w/ui/flow` but cannot import itself. */
+export interface WorkflowFieldCtx {
+    /** `@w6w/ui/flow`'s `isTriggerApp`, injected by the JSX caller. */
+    isTriggerApp: (app: string) => boolean;
+    /** `@w6w/ui/flow`'s `asFieldDefs`, injected by the JSX caller. */
+    asFieldDefs: (fields: unknown) => TriggerFieldDefLike[];
+}
+/** One field of the normalized list `TargetSelector` resolves to (A5). */
+export interface TargetField {
+    key: string;
+    label: string;
+    type: string;
+    required?: boolean;
+    default?: unknown;
+    showIf?: ShowIfPredicate;
+}
+/** One row of an input-contract list (`FunctionInput`/`EndpointInput`'s common shape). */
+export interface InputRowLike {
+    key: string;
+    label: string;
+    type: string;
+    required?: boolean;
+}
+/** The concrete ref (`fn_…` / `wf_…` / `ep_…`) a CallableRef/endpoint target
+ *  currently points at, `""` for `action`. */
+export declare function targetRef(target: TargetLike): string;
+/** Is the target fully chosen? An action needs both halves of its `uses` pair (A9). */
+export declare function targetIsBound(target: TargetLike): boolean;
+/**
+ * Adapt a Function's `impl` into the shape `TargetSelector` consumes (D-8):
+ * an action impl to the `action` arm exactly as before; a CallableRef impl maps
+ * its `kind`/`function`|`workflow` across UNCHANGED — deliberately dropping
+ * `with`/`outputMap`, which `TargetLike`'s CallableRef arm has no slot for (they
+ * survive on `draft.impl` itself; `targetToImpl` restores a default `with` on
+ * the way back, so `implToTarget(targetToImpl(x))` round-trips `x`). An
+ * absent impl still yields the empty action target.
+ */
+export declare function implToTarget(impl: FunctionImplLike | undefined): ActionTargetLike | CallableTargetLike;
+/**
+ * Inverse of {@link implToTarget}, over the widened D-8 domain. Never yields
+ * `with: undefined` on EITHER arm — A10: `invoke-function.ts`'s
+ * `resolveWith(impl.with, …)` call is unconditional and shared by both arms
+ * (the CallableRef arm has its own `with` adapter pass onto the callee's inputs,
+ * unlike `uncoveredForEndpoint`'s P3), so an unmapped `with` must still be
+ * `{}`, not absent, on a CallableRef impl too.
+ */
+export declare function targetToImpl(target: ActionTargetLike | CallableTargetLike): FunctionImplLike;
+/** Project a list of action/function params into the normalized `TargetField[]` (A5). */
+export declare function paramsToFields(params: ParamLike[]): TargetField[];
+/**
+ * A6: project every manual/webhook-trigger step's `with.fields` from a raw
+ * workflow graph into the union of `TargetField`s, keyed by `key`, first
+ * occurrence wins, order stable (planner D-2: the server broadcasts one
+ * `input` object to every trigger identically). A webhook/scheduler step that
+ * declares `methods`/`auth` but no `fields` contributes nothing — by reading
+ * `with.fields`, not a special case. Unnamed/blank keys are skipped. `default`
+ * is not carried for this arm (A5). A missing/garbage graph, or one whose
+ * `isTriggerApp` predicate matches nothing, yields `[]` — never a throw.
+ */
+export declare function fieldsFromWorkflow(workflow: WorkflowLike | null | undefined, ctx: WorkflowFieldCtx): TargetField[];

package/dist/lib/workflow-blank.d.ts

@@ -0,0 +1,2 @@
+/** A fresh, minimal workflow definition for a brand-new id (a new object on every call). */
+export declare function blankDefinition(id: string): Record<string, unknown>;

package/dist/lib.mjs

@@ -1,62 +1,84 @@
 "use client";
-import { A as n, b as d, d as c, a as u, c as p, e as m, f as S, g as f, h as g, i as v, j as w, k as R, l as b, m as h, n as y, o as F, p as A, q as K, r as C, s as D, t as E, u as I, v as x, w as P, x as V, y as L, z as U, B as k, C as H, D as W, E as _, F as j, G, H as N, I as O, J as q, K as z, L as B, M as J, N as M, O as T } from "./slug-ByKQgxrf.js";
-import { i as Q, s as X } from "./spec-import-invalidation-D3retX4Q.js";
+import { d as n, i as d, a as c, r as p, b as u, c as m, e as f, s as S, t as g, f as v, v as b, g as w, w as F, h as R } from "./trigger-preview-VPkrryDl.js";
+import { d as x, e as y, i as I, p as A, t as E } from "./document-sources-C0grrtdq.js";
+import { e as P, h as D, a as T, b as C, i as U, m as V, p as k, r as L, s as W, v as _, w as H } from "./rail-settings-XYGToh00.js";
+import { c as j, d as q, i as B, p as G } from "./settings-rail--GdRMusb.js";
+import { A as Y, b as $, f as z, i as J, a as M, c as Q, s as X, u as Z } from "./slug-C4ktDPdy.js";
+import { i as ea, s as sa } from "./spec-import-invalidation-D3retX4Q.js";
+import { b as ta } from "./workflow-blank-DyL3_RUA.js";
+import { I as oa, c as la, f as na, i as da, a as ca, m as pa, p as ua, s as ma, t as fa, b as Sa, d as ga, u as va, e as ba, g as wa } from "./coerce-input-BicYr7nc.js";
 function t(s) {
   const e = new URLSearchParams(s), a = e.get("edit");
   if (a === null || a === "") return null;
   e.delete("edit");
-  const i = e.toString();
-  return { id: a, search: i === "" ? "" : `?${i}` };
+  const r = e.toString();
+  return { id: a, search: r === "" ? "" : `?${r}` };
 }
-function r(s) {
+function i(s) {
   const a = new URLSearchParams(s).get("run");
   return a != null && a.startsWith("run_") ? a : null;
 }
 export {
-  n as ACCOUNT_SLUG_RE,
-  d as buildSnippet,
-  c as definitionWithPolicy,
-  u as documentSampleValues,
-  p as duplicateKeyIndexes,
-  m as errorHandlerSelfDecision,
-  S as evaluateEdit,
-  f as filterKeyInput,
-  g as hasDefinitionActions,
-  v as hasDelete,
-  w as hasVersionHistory,
-  R as invalidReason,
-  Q as invalidateImportedCallable,
-  b as isCodeRailAvailable,
-  h as isEndpointKey,
-  y as isExprDefault,
-  F as isRowArchived,
-  A as isSettingsRailAvailable,
-  K as isUrnAddressable,
-  C as isValidAccountSlug,
+  Y as ACCOUNT_SLUG_RE,
+  oa as INPUT_TYPES,
+  ta as blankDefinition,
+  $ as buildSnippet,
+  j as callableRecord,
+  la as coerceInput,
+  q as definitionWithPolicy,
+  x as documentSampleValues,
+  n as duplicateKeyIndexes,
+  y as errorHandlerSelfDecision,
+  P as evaluateEdit,
+  na as fieldsFromWorkflow,
+  z as filterKeyInput,
+  D as hasDefinitionActions,
+  T as hasDelete,
+  C as hasVersionHistory,
+  da as implToTarget,
+  ca as inputsForSave,
+  d as invalidReason,
+  ea as invalidateImportedCallable,
+  I as isCodeRailAvailable,
+  J as isEndpointKey,
+  c as isExprDefault,
+  U as isRowArchived,
+  B as isSettingsRailAvailable,
+  M as isUrnAddressable,
+  Q as isValidAccountSlug,
   t as legacyEditRedirect,
-  D as metadataFieldsForKind,
-  E as parseImportPaste,
-  I as policyFromDefinition,
-  x as projectDocumentSources,
-  P as readSettings,
-  V as readVariables,
-  L as readWorkflowStatus,
-  U as restoreRailState,
-  k as runFormFields,
-  r as runParamFromSearch,
-  H as slugify,
+  pa as mergeSeed,
+  V as metadataFieldsForKind,
+  ua as paramsToFields,
+  k as parseImportPaste,
+  G as policyFromDefinition,
+  A as projectDocumentSources,
+  p as readSettings,
+  u as readVariables,
+  m as readWorkflowStatus,
+  L as restoreRailState,
+  f as runFormFields,
+  i as runParamFromSearch,
+  ma as shouldSeed,
+  X as slugify,
   W as specCollectionForKind,
-  X as specImportListKey,
-  _ as stepValid,
-  j as toSnippetCallable,
-  G as triggerInputSeed,
-  N as triggerPreviews,
-  O as unavailableReason,
-  q as variablesForSave,
-  z as varsRailFor,
-  B as visibleRows,
-  J as workflowKeyEditAllowed,
-  M as workflowValid,
-  T as writeSetting
+  sa as specImportListKey,
+  S as stepValid,
+  fa as targetIsBound,
+  Sa as targetRef,
+  ga as targetToImpl,
+  E as toSnippetCallable,
+  g as triggerInputSeed,
+  v as triggerPreviews,
+  Z as unavailableReason,
+  va as uncoveredForEndpoint,
+  ba as uncoveredForFunction,
+  wa as uncoveredRequiredKeys,
+  b as variablesForSave,
+  w as varsRailFor,
+  _ as visibleRows,
+  H as workflowKeyEditAllowed,
+  F as workflowValid,
+  R as writeSetting
 };
 //# sourceMappingURL=lib.mjs.map

package/dist/lib.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"lib.mjs","sources":["../src/lib/workflow-route.ts"],"sourcesContent":["// T4.1.1 (R-3): `/<account>/<project>/workflows/:id` is the workflow visual\n// editor's canonical URL; the older `workflows?edit=<id>` form survives only as\n// an alias. Parsing that alias is a pure URL question with no React and no\n// router in it, so it lives here — `.ts`, zero imports — rather than inline in\n// `WorkflowsPage.tsx`, which `node --test` cannot load (JSX).\n\n/**\n * Read the legacy `edit` parameter off a location's search string.\n *\n * Returns `null` when there is nothing to redirect: no `edit` key at all, or\n * one that is empty (`?edit=` is not an id). Otherwise `id` is the `edit`\n * value and `search` is the rest of the query — `edit` removed, every other\n * parameter kept in its original order — as a leading-`?` search string, or\n * `\"\"` when nothing is left.\n *\n *   legacyEditRedirect(\"?edit=wf_a\")                  // { id: \"wf_a\", search: \"\" }\n *   legacyEditRedirect(\"?edit=wf_a&tab=steps\")        // { id: \"wf_a\", search: \"?tab=steps\" }\n */\nexport function legacyEditRedirect(search: string): { id: string; search: string } | null {\n  const params = new URLSearchParams(search);\n  const id = params.get(\"edit\");\n  if (id === null || id === \"\") return null;\n  params.delete(\"edit\");\n  const rest = params.toString();\n  return { id, search: rest === \"\" ? \"\" : `?${rest}` };\n}\n\n// T2.4.2 — the History page's \"open in visual view\" link lands on\n// `workflows/:id?run=<runId>`; `WorkflowsPage` reads the `run` param on mount\n// and seeds `activeRunId` from it (EXTEND, not rebuild — the live-run\n// overlay machinery already handles a terminal run identically to a live\n// one). Guarded to `run_`-prefixed values only, so an unrelated/garbled\n// param (or this file's OWN `edit` alias from a stale link) never gets\n// treated as a run id.\n\n/**\n * Read the `run` query param off a location's search string, honouring it\n * only when it looks like a real run id.\n *\n *   runParamFromSearch(\"?run=run_1&x=1\")   // \"run_1\"\n *   runParamFromSearch(\"?run=\")            // null\n *   runParamFromSearch(\"?run=wf_1\")        // null — not a run id\n *   runParamFromSearch(\"\")                 // null\n */\nexport function runParamFromSearch(search: string): string | null {\n  const params = new URLSearchParams(search);\n  const run = params.get(\"run\");\n  return run?.startsWith(\"run_\") ? run : null;\n}\n"],"names":["legacyEditRedirect","search","params","id","rest","runParamFromSearch","run"],"mappings":";;;AAkBO,SAASA,EAAmBC,GAAuD;AACxF,QAAMC,IAAS,IAAI,gBAAgBD,CAAM,GACnCE,IAAKD,EAAO,IAAI,MAAM;AAC5B,MAAIC,MAAO,QAAQA,MAAO,GAAI,QAAO;AACrC,EAAAD,EAAO,OAAO,MAAM;AACpB,QAAME,IAAOF,EAAO,SAAA;AACpB,SAAO,EAAE,IAAAC,GAAI,QAAQC,MAAS,KAAK,KAAK,IAAIA,CAAI,GAAA;AAClD;AAmBO,SAASC,EAAmBJ,GAA+B;AAEhE,QAAMK,IADS,IAAI,gBAAgBL,CAAM,EACtB,IAAI,KAAK;AAC5B,SAAOK,KAAA,QAAAA,EAAK,WAAW,UAAUA,IAAM;AACzC;"}
+{"version":3,"file":"lib.mjs","sources":["../src/lib/workflow-route.ts"],"sourcesContent":["// T4.1.1 (R-3): `/<account>/<project>/workflows/:id` is the workflow visual\n// editor's canonical URL; the older `workflows?edit=<id>` form survives only as\n// an alias. Parsing that alias is a pure URL question with no React and no\n// router in it, so it lives here — `.ts`, zero imports — rather than inline in\n// `WorkflowsPage.tsx`, which `node --test` cannot load (JSX).\n\n/**\n * Read the legacy `edit` parameter off a location's search string.\n *\n * Returns `null` when there is nothing to redirect: no `edit` key at all, or\n * one that is empty (`?edit=` is not an id). Otherwise `id` is the `edit`\n * value and `search` is the rest of the query — `edit` removed, every other\n * parameter kept in its original order — as a leading-`?` search string, or\n * `\"\"` when nothing is left.\n *\n *   legacyEditRedirect(\"?edit=wf_a\")                  // { id: \"wf_a\", search: \"\" }\n *   legacyEditRedirect(\"?edit=wf_a&tab=steps\")        // { id: \"wf_a\", search: \"?tab=steps\" }\n */\nexport function legacyEditRedirect(search: string): { id: string; search: string } | null {\n  const params = new URLSearchParams(search);\n  const id = params.get(\"edit\");\n  if (id === null || id === \"\") return null;\n  params.delete(\"edit\");\n  const rest = params.toString();\n  return { id, search: rest === \"\" ? \"\" : `?${rest}` };\n}\n\n// T2.4.2 — the History page's \"open in visual view\" link lands on\n// `workflows/:id?run=<runId>`; `WorkflowsPage` reads the `run` param on mount\n// and seeds `activeRunId` from it (EXTEND, not rebuild — the live-run\n// overlay machinery already handles a terminal run identically to a live\n// one). Guarded to `run_`-prefixed values only, so an unrelated/garbled\n// param (or this file's OWN `edit` alias from a stale link) never gets\n// treated as a run id.\n\n/**\n * Read the `run` query param off a location's search string, honouring it\n * only when it looks like a real run id.\n *\n *   runParamFromSearch(\"?run=run_1&x=1\")   // \"run_1\"\n *   runParamFromSearch(\"?run=\")            // null\n *   runParamFromSearch(\"?run=wf_1\")        // null — not a run id\n *   runParamFromSearch(\"\")                 // null\n */\nexport function runParamFromSearch(search: string): string | null {\n  const params = new URLSearchParams(search);\n  const run = params.get(\"run\");\n  return run?.startsWith(\"run_\") ? run : null;\n}\n"],"names":["legacyEditRedirect","search","params","id","rest","runParamFromSearch","run"],"mappings":";;;;;;;;;AAkBO,SAASA,EAAmBC,GAAuD;AACxF,QAAMC,IAAS,IAAI,gBAAgBD,CAAM,GACnCE,IAAKD,EAAO,IAAI,MAAM;AAC5B,MAAIC,MAAO,QAAQA,MAAO,GAAI,QAAO;AACrC,EAAAD,EAAO,OAAO,MAAM;AACpB,QAAME,IAAOF,EAAO,SAAA;AACpB,SAAO,EAAE,IAAAC,GAAI,QAAQC,MAAS,KAAK,KAAK,IAAIA,CAAI,GAAA;AAClD;AAmBO,SAASC,EAAmBJ,GAA+B;AAEhE,QAAMK,IADS,IAAI,gBAAgBL,CAAM,EACtB,IAAI,KAAK;AAC5B,SAAOK,KAAA,QAAAA,EAAK,WAAW,UAAUA,IAAM;AACzC;"}

package/dist/lists/ActivitySummary.d.ts

@@ -0,0 +1,29 @@
+import { MouseEvent, ReactElement, ReactNode } from 'react';
+import { ActivityTileTarget } from '../lib/recent-activity.ts';
+export type { ActivityTileTarget };
+export interface ActivitySummaryProps {
+    /** Real `href` for a resolved name; given ⇒ the title is an `<a>` (middle-click, new tab). */
+    getHref?: (target: ActivityTileTarget) => string;
+    /** A click on a resolved name. Never `preventDefault`ed here: the host decides. */
+    onOpen?: (target: ActivityTileTarget, event: MouseEvent<Element>) => void;
+    slots?: {
+        /** Above everything (after the error banner). */
+        header?: ReactNode;
+        /** A row of host actions under `header`. */
+        actions?: ReactNode;
+        /** Replaces the "No runs yet…" copy. */
+        empty?: ReactNode;
+        /** Between the two headline rows and "Activity over time" (Studio puts its board here). */
+        betweenHeadlineAndSeries?: ReactNode;
+    };
+}
+/**
+ * The account's run statistics and recent activity: "Today" and "Last 7 days" headline cards,
+ * "Activity over time" and "Recent activity". Account-scoped (no `project`); it never navigates —
+ * opening a resolved name is the host's `onOpen` / `getHref`.
+ *
+ * Two `/dashboard/stats` requests, deliberately: `today` is `{ from: <local start of day>,
+ * bucket: "day" }` and `week` is `{ bucket: "week" }`. The server's only buckets are `day|week`,
+ * cut in the database's timezone, so no single request can cut at the viewer's local midnight.
+ */
+export declare function ActivitySummary({ getHref, onOpen, slots }: ActivitySummaryProps): ReactElement;

package/dist/lists/CallableKindList.d.ts

@@ -0,0 +1,34 @@
+import { CallableListProps, CallableListRow } from '@w6w/ui';
+import { ReactNode } from 'react';
+import { CallableKind } from '../lib/callable-descriptors.ts';
+import { ArchivableRow } from '../lib/rail-settings.ts';
+/**
+ * The internal frame the three kind lists (`FunctionList`, `EndpointList`, `WorkflowList`) share:
+ * ui's presentational `CallableList` filled with one kind's copy and test ids, the archived
+ * decision, and the Import flow. Never re-exported from `./lists` — the public surface is the three
+ * kind components.
+ *
+ * It renders the one `.w6w-embed-root` of the list (a kind's create modal rides in as `children`,
+ * inside that root) and navigates nowhere: opening is `onOpen`/`getHref`, an imported row opens
+ * through `onOpen` too.
+ */
+export declare function CallableKindList<Row extends {
+    id: string;
+} & ArchivableRow>(props: {
+    kind: CallableKind;
+    /** `undefined` while the list query has not answered. */
+    rows: readonly Row[] | undefined;
+    loading: boolean;
+    /** Everything about a row except the id and the archived flag, which the frame owns. */
+    toRow: (row: Row) => Omit<CallableListRow, "id" | "archived">;
+    /** Only the Import flow reads it (the workflow list key); `null` means no project. */
+    project: string | null;
+    onOpen?: (id: string, event?: React.MouseEvent<Element>) => void;
+    getHref?: (id: string) => string;
+    onCreate: () => void;
+    creating?: boolean;
+    error?: string | null;
+    slots?: CallableListProps["slots"];
+    /** The kind's create modal. */
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/lists/ConnectionDetail.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+export interface ConnectionDetailProps {
+    connectionId: string;
+    /** An action row calls `(actionKey)`; one of its saved tests calls `(actionKey, savedTestId)`. */
+    onOpenAction: (actionKey: string, savedTestId?: string) => void;
+    /** The back affordance renders only when given. */
+    onBack?: () => void;
+    slots?: {
+        /** Replaces the header block. */
+        header?: ReactNode;
+        /** Appended to the header's buttons. */
+        actions?: ReactNode;
+        /** Replaces the not-found state. */
+        empty?: ReactNode;
+    };
+}
+export declare function ConnectionDetail({ connectionId, onOpenAction, onBack, slots, }: ConnectionDetailProps): import("react").JSX.Element;

package/dist/lists/ConnectionList.d.ts

@@ -0,0 +1,16 @@
+import { ConnectionListProps as UiConnectionListProps } from '@w6w/ui';
+import { MouseEvent } from 'react';
+export interface ConnectionListProps {
+    /** Row click; the host decides whether to `preventDefault` when it also passes `getHref`. */
+    onOpen?: (id: string, event: MouseEvent<Element>) => void;
+    /** When set, each openable row is a real `<a href>`. */
+    getHref?: (id: string) => string;
+    /** Label of the default Add button. Default `+ Add connection`. */
+    addLabel?: string;
+    /**
+     * `header` and `empty` pass through. A given `actions` key (even `null`) replaces the default
+     * Add button.
+     */
+    slots?: UiConnectionListProps["slots"];
+}
+export declare function ConnectionList({ onOpen, getHref, addLabel, slots }: ConnectionListProps): import("react").JSX.Element;

package/dist/lists/DocumentList.d.ts

@@ -0,0 +1,29 @@
+import { MouseEvent, ReactNode } from 'react';
+import { DocWithProvenance } from '../repos/documents.ts';
+/** A per-row slot: called once per rendered row with that row's document. */
+export type DocumentRowSlot = (doc: DocWithProvenance) => ReactNode;
+export interface DocumentListRowSlots {
+    /** Before the row's main text, inside the open control (e.g. a source icon). */
+    lead?: DocumentRowSlot;
+    /** The action group of a SHARED row (a shared row has no Edit or Delete). */
+    sharedActions?: DocumentRowSlot;
+    /** A full-width line under the row (e.g. a per-row error). */
+    footer?: DocumentRowSlot;
+}
+export interface DocumentListSlots {
+    /** Replaces the section heading and its description (the Add button stays). `null`: none. */
+    header?: ReactNode;
+    /** Replaces the empty-state copy. `null`: nothing. */
+    empty?: ReactNode;
+}
+export interface DocumentListProps {
+    /** Omitted: the provider's project. `null` or `""`: none; nothing is read and writes refuse. */
+    project?: string | null;
+    /** The host decides what opening a row means; with `getHref` it may `preventDefault`. */
+    onOpen?: (id: string, event: MouseEvent<Element>) => void;
+    /** Given, a row's main area is a real `<a href>`; its click still calls `onOpen`. */
+    getHref?: (id: string) => string;
+    slots?: DocumentListSlots;
+    rowSlots?: DocumentListRowSlots;
+}
+export declare function DocumentList({ project, onOpen, getHref, slots, rowSlots }: DocumentListProps): import("react").JSX.Element;

package/dist/lists/EndpointList.d.ts

@@ -0,0 +1,19 @@
+import { CallableListProps } from '@w6w/ui';
+export interface EndpointListProps {
+    /** Project for Import only (the Endpoints list itself is account-wide). Omitted: the provider's. */
+    project?: string | null;
+    /** A row was clicked, or an import completed. Navigation is the host's. */
+    onOpen?: (id: string, event?: React.MouseEvent<Element>) => void;
+    /** When set, each row is a real `<a href>`; a click still calls `onOpen`. */
+    getHref?: (id: string) => string;
+    /** An Endpoint was created from the list's New button; receives the SERVER's id. */
+    onCreated?: (id: string) => void;
+    slots?: CallableListProps["slots"];
+}
+/**
+ * The account's Endpoints: rows from `GET /endpoints`, archived ones behind a Show-archived toggle,
+ * an "Unfinished" tag on drafts (no target yet), a New button that creates an Endpoint
+ * (create-first: the row is POSTed before any editor exists), and Import. Never navigates — the
+ * host wires `onOpen` / `getHref` / `onCreated`.
+ */
+export declare function EndpointList(props: EndpointListProps): import("react").JSX.Element;

package/dist/lists/FunctionList.d.ts

@@ -0,0 +1,18 @@
+import { CallableListProps } from '@w6w/ui';
+export interface FunctionListProps {
+    /** Project for Import only (the Functions list itself is account-wide). Omitted: the provider's. */
+    project?: string | null;
+    /** A row was clicked, or an import completed. Navigation is the host's. */
+    onOpen?: (id: string, event?: React.MouseEvent<Element>) => void;
+    /** When set, each row is a real `<a href>`; a click still calls `onOpen`. */
+    getHref?: (id: string) => string;
+    /** A Function was created from the list's New button; receives the SERVER's id. */
+    onCreated?: (id: string) => void;
+    slots?: CallableListProps["slots"];
+}
+/**
+ * The account's Functions: rows from `GET /functions`, archived ones behind a Show-archived toggle,
+ * a New button that creates a Function (create-first: the row is POSTed before any editor exists),
+ * and Import. Never navigates — the host wires `onOpen` / `getHref` / `onCreated`.
+ */
+export declare function FunctionList(props: FunctionListProps): import("react").JSX.Element;

package/dist/lists/ReliabilityBoard.d.ts

@@ -0,0 +1,23 @@
+import { ReliabilityListProps } from '@w6w/ui';
+import { MouseEvent, ReactElement } from 'react';
+export interface ReliabilityBoardProps {
+    /** Omitted ⇒ the provider's project; `null`/`""` ⇒ no request and a "select a project" note. */
+    project?: string | null;
+    variant?: "full" | "compact";
+    /** DISPLAY cap passed to the list; never sent to the server (it would falsify "x of y"). */
+    limit?: number;
+    /** Window size in days: sent with both requests and labels the table column (default 30). */
+    days?: number;
+    showChart?: boolean;
+    getHref?: (appId: string) => string;
+    onOpen?: (appId: string, event: MouseEvent<Element>) => void;
+    showAllHref?: string;
+    onShowAll?: (event: MouseEvent<Element>) => void;
+    slots?: ReliabilityListProps["slots"];
+}
+/**
+ * One project's service reliability: loads members then status in serial batches of at most ten
+ * through `@w6w/embed/repos`, and draws it with `@w6w/ui`'s `ReliabilityList`. Icons come from the
+ * rows themselves, so no app-catalog request is made.
+ */
+export declare function ReliabilityBoard({ project, variant, limit, days, showChart, getHref, onOpen, showAllHref, onShowAll, slots, }: ReliabilityBoardProps): ReactElement;