@walkeros/mcp 4.6.1 → 4.7.0-next-1790187973605

package/dist/index.d.ts

@@ -1051,8 +1051,8 @@ declare const FRAME_MANAGE_INPUT_SCHEMA: {
 declare const FRAME_HINT_OPEN_PAGE_OR_GET = "Use action \"page\" with a pageKey (a frame\u2019s source.key) to read a page with marks, or action \"get\" with a frameId.";
 declare const FRAME_HINT_NAMES_ARE_DOCUMENTATION = "Frame names are documentation; the marks inside a frame carry the meaning.";
 declare const FRAME_HINT_NONE_YET = "This project has no frames yet. Frames are drawn in Tag Mode or the app, not through this tool.";
-declare const FRAME_HINT_MARK_SPACE = "Marks are in their frame\u2019s own 0..1 space; a child frame sits inside its parent through placements[].rect.";
-declare const FRAME_HINT_READ_KNOWLEDGE = "Use hub_manage action \"knowledge\" with frameId (and markId) to read what people wrote here. A markId is an id from these marks, and an entity action is addressed by its own id, never by its raw text.";
+declare const FRAME_HINT_MARK_SPACE = "Tag geometry is fractional: a rect is 0..1 of its frame, and an at is 0..1 of its parent tag\u2019s box, or of the frame for a root tag; a child frame sits inside its parent through placements[].rect.";
+declare const FRAME_HINT_READ_KNOWLEDGE = "Use hub_manage action \"knowledge\" with frameId (and markId) to read what people wrote here. A markId is a tag id from these marks, and a tag\u2019s threadRef is the id of its thread entry there.";
 declare const FRAME_HINT_NONE_ON_PAGE = "No frames on this page. Check the pageKey against the source.key values from action \"list\".";
 declare const FRAME_HINT_EXTENDS_BASE = "This frame extends another and stores only what it adds; read the base frame (extends) for the rest.";
 declare const FRAME_NOT_FOUND_HINT = "Use action \"list\" or \"page\" to find frame ids.";

package/dist/index.js

@@ -2024,7 +2024,7 @@ var HUB_MANAGE_INPUT_SCHEMA = {
     'One frame (frm_...), the named rectangle a note hangs on. Action "knowledge" only. Narrower than pageKey, since a page holds several frames.'
   ),
   markId: z8.string().min(1).max(MAX_MARK_ID_LENGTH).optional().describe(
-    'One mark within "frameId". Action "knowledge" only, and refused without frameId, since a mark id alone addresses nothing. Naming a mark is also what attaches the message bodies.'
+    'One tag within "frameId", by its tag id (the id of an entry in frame_manage marks.tags). Action "knowledge" only, and refused without frameId, since a mark id alone addresses nothing. Naming a mark is also what attaches the message bodies.'
   )
 };
 var annotations8 = {
@@ -2560,7 +2560,7 @@ import { mcpResult as mcpResult9, mcpError as mcpError9 } from "@walkeros/core";
 var FRAME_ID_PATTERN2 = /^frm_[A-Za-z0-9_-]{21}$/;
 var MAX_PAGE_KEY_CHARS = 1024;
 var TITLE9 = "Frames";
-var FRAME_MANAGE_DESCRIPTION = 'Read the frames of a measurement plan: named rectangles with marks inside them, drawn in Tag Mode or in the app. Actions: list (every frame of the project, without marks), page (the frames of one page at any depth, with marks), get (one frame with its marks). Read-only: frames are drawn and edited in Tag Mode or the app, never here. A frame name is documentation; the marks inside it carry the meaning. A frame that extends another stores only what it adds. Use hub_manage action "knowledge" with a frameId or markId to read what people wrote on a frame. A markId is an id read from the marks of a frame here: mark ids come back literal so they can be passed straight back, while the text around them is wrapped as data. An entity action is an object carrying its id beside the raw attribute text, because the id is the address and the raw text is not.';
+var FRAME_MANAGE_DESCRIPTION = 'Read the frames of a measurement plan: named rectangles with marks inside them, drawn in Tag Mode or in the app. Actions: list (every frame of the project, without marks), page (the frames of one page at any depth, with marks), get (one frame with its marks). Read-only: frames are drawn and edited in Tag Mode or the app, never here. A frame name is documentation; the marks inside it carry the meaning. A frame that extends another stores only what it adds, so its tags may carry only the fields they change. Marks are { tags, note }: tags is one flat list of tags, each with an id, a kind such as entity, property or action, a name, and a parentId naming the tag it sits under; note is the frame\u2019s own description and thread. Use hub_manage action "knowledge" with a frameId or markId to read what people wrote on a frame. A markId is a tag id: a tag\u2019s id, parentId and threadRef come back literal when they have the shape the app mints, so they can be passed straight back; every other string value in the marks is wrapped as data, and so is an object key that is not a plain identifier.';
 var FRAME_MANAGE_INPUT_SCHEMA = {
   action: z9.enum(["list", "page", "get"]).describe(
     "list the project\u2019s frames, read one page with marks, or read one frame"
@@ -2584,8 +2584,8 @@ var annotations9 = {
 var FRAME_HINT_OPEN_PAGE_OR_GET = 'Use action "page" with a pageKey (a frame\u2019s source.key) to read a page with marks, or action "get" with a frameId.';
 var FRAME_HINT_NAMES_ARE_DOCUMENTATION = "Frame names are documentation; the marks inside a frame carry the meaning.";
 var FRAME_HINT_NONE_YET = "This project has no frames yet. Frames are drawn in Tag Mode or the app, not through this tool.";
-var FRAME_HINT_MARK_SPACE = "Marks are in their frame\u2019s own 0..1 space; a child frame sits inside its parent through placements[].rect.";
-var FRAME_HINT_READ_KNOWLEDGE = 'Use hub_manage action "knowledge" with frameId (and markId) to read what people wrote here. A markId is an id from these marks, and an entity action is addressed by its own id, never by its raw text.';
+var FRAME_HINT_MARK_SPACE = "Tag geometry is fractional: a rect is 0..1 of its frame, and an at is 0..1 of its parent tag\u2019s box, or of the frame for a root tag; a child frame sits inside its parent through placements[].rect.";
+var FRAME_HINT_READ_KNOWLEDGE = 'Use hub_manage action "knowledge" with frameId (and markId) to read what people wrote here. A markId is a tag id from these marks, and a tag\u2019s threadRef is the id of its thread entry there.';
 var FRAME_HINT_NONE_ON_PAGE = 'No frames on this page. Check the pageKey against the source.key values from action "list".';
 var FRAME_HINT_EXTENDS_BASE = "This frame extends another and stores only what it adds; read the base frame (extends) for the rest.";
 var FRAME_NOT_FOUND_HINT = 'Use action "list" or "page" to find frame ids.';
@@ -2621,67 +2621,59 @@ function serializeLean(frame) {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function actionMarkId(entityId, raw) {
-  return `${entityId}#action.${raw}`;
-}
-var MARK_ADDRESS_KEYS = /* @__PURE__ */ new Set([
-  // The mark id itself, and a component of the data and action addresses.
-  "id",
-  // The first half of an ambient address, `ambient.<kind>.<key>`, and the
-  // discriminator a reader branches on.
-  "kind",
-  // An entity's pointer at another entity, which is that entity's mark id.
-  "link",
-  // The thread a note became, which action "note_add" takes as threadId.
-  "threadRef"
+var TAG_ID_PATTERN = /^[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*(?:#(?:data\.v?[0-9]+|action\.[0-9]+|context\.[0-9]+|[0-9]+))?$/;
+var MAX_TAG_ID_CHARS = 200;
+var THREAD_ID_PATTERN = /^thr_[a-z0-9]{21}$/;
+var isTagId = (value) => value.length <= MAX_TAG_ID_CHARS && TAG_ID_PATTERN.test(value);
+var isThreadId = (value) => THREAD_ID_PATTERN.test(value);
+var TAG_ADDRESSES = /* @__PURE__ */ new Map([
+  // The tag id: the markId `hub_manage` action "knowledge" takes, which the
+  // app joins to the frame id as the anchor key `<frameId>:<markId>`.
+  ["id", isTagId],
+  // The tag this one sits under, which is that tag's id: the only relation
+  // between tags, so a reader joins it to `id` to rebuild the tree, and it is
+  // a markId in its own right.
+  ["parentId", isTagId],
+  // The hub thread this tag's note thread became: the `id` of the thread
+  // entry `hub_manage` action "knowledge" returns for this tag.
+  ["threadRef", isThreadId]
 ]);
-var MARK_ADDRESS_LIST_KEYS = /* @__PURE__ */ new Set([
-  // The entities a context band covers, by their mark ids.
-  "covers"
-]);
-var MARK_PAGE_DATA_KEYS = /* @__PURE__ */ new Set(["anchor", "actionAnchors"]);
-function isProseKeyedRecord(key, owner) {
-  return key === "data" && typeof owner.kind !== "string";
-}
-function walkMarks(value, inPageData = false) {
+var NOTE_ADDRESSES = /* @__PURE__ */ new Map(
+  [["threadRef", isThreadId]]
+);
+var MARK_KEY_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$-]{0,63}$/;
+var markKey = (key) => MARK_KEY_PATTERN.test(key) ? key : wrapUserData(key);
+function walkText(value) {
   if (typeof value === "string") return wrapUserData(value);
-  if (Array.isArray(value)) {
-    return value.map((item) => walkMarks(item, inPageData));
-  }
+  if (Array.isArray(value)) return value.map(walkText);
   if (!isRecord2(value)) return value;
-  const entityId = typeof value.id === "string" ? value.id : void 0;
   const out = {};
   for (const [key, child] of Object.entries(value)) {
-    if (MARK_PAGE_DATA_KEYS.has(key)) {
-      out[key] = walkMarks(child, true);
-    } else if (!inPageData && isRecord2(child) && isProseKeyedRecord(key, value)) {
-      out[key] = proseKeyedPairs(child);
+    out[markKey(key)] = walkText(child);
+  }
+  return out;
+}
+function walkMarks(marks) {
+  const out = {};
+  for (const [key, value] of Object.entries(marks)) {
+    if (key === "tags" && Array.isArray(value)) {
+      out[key] = value.map((tag) => walkAddressed(tag, TAG_ADDRESSES));
+    } else if (key === "note") {
+      out[key] = walkAddressed(value, NOTE_ADDRESSES);
     } else {
-      out[key] = walkMarkEntry(key, child, entityId, inPageData);
+      out[markKey(key)] = walkText(value);
     }
   }
   return out;
 }
-function proseKeyedPairs(record) {
-  return Object.entries(record).map(([key, value]) => ({
-    key: wrapUserData(key),
-    value: walkMarks(value)
-  }));
-}
-function walkMarkEntry(key, child, entityId, inPageData) {
-  if (inPageData) return walkMarks(child, true);
-  if (MARK_ADDRESS_KEYS.has(key) && typeof child === "string") return child;
-  if (MARK_ADDRESS_LIST_KEYS.has(key) && Array.isArray(child)) {
-    return child.map(
-      (item) => typeof item === "string" ? item : walkMarks(item)
-    );
-  }
-  if (key === "actions" && entityId !== void 0 && Array.isArray(child)) {
-    return child.map(
-      (raw) => typeof raw === "string" ? { id: actionMarkId(entityId, raw), raw: wrapUserData(raw) } : walkMarks(raw)
-    );
+function walkAddressed(value, addresses) {
+  if (!isRecord2(value)) return walkText(value);
+  const out = {};
+  for (const [key, field] of Object.entries(value)) {
+    const isAddress = addresses.get(key);
+    out[markKey(key)] = isAddress !== void 0 && typeof field === "string" && isAddress(field) ? field : walkText(field);
   }
-  return walkMarks(child);
+  return out;
 }
 function serializeFrame(frame) {
   return {
@@ -2833,7 +2825,7 @@ async function feedbackHandlerBody(client, input) {
     const isAnonymous = explicitAnonymous ?? anonymous ?? true;
     await client.submitFeedback(text, {
       anonymous: isAnonymous,
-      version: "4.6.1"
+      version: "4.7.0-next-1790187973605"
     });
     return mcpResult10({ ok: true });
   } catch (error) {
@@ -3196,7 +3188,7 @@ var inputSchema11 = {
   // Override the (optional) CLI `step` shape: the simulate handler hard-requires
   // a target step (no all-steps mode), so the registered schema must be honest.
   step: z12.string().describe(
-    'Required. Target step as "type.name" \u2014 e.g. "source.demo", "destination.gtag", "transformer.router".'
+    'Required. Target step as "type.name", e.g. "source.demo", "collector.default", "destination.gtag", "transformer.router". A collector step runs enrichment and then collector.next, returning every event the destinations would receive (none after a stop).'
   ),
   verbose: z12.boolean().optional().describe("Include full payload per destination (default: false)"),
   ingest: z12.record(z12.string(), z12.unknown()).optional().describe(
@@ -3469,7 +3461,7 @@ var NPM_SEARCH_URL = "https://registry.npmjs.org/-/v1/search";
 var JSDELIVR_BASE = "https://cdn.jsdelivr.net/npm";
 var WALKEROS_JSON_PATH = "dist/walkerOS.json";
 var CACHE_TTL = 5 * 60 * 1e3;
-var CLIENT_HEADER = "walkeros-mcp/4.6.1";
+var CLIENT_HEADER = "walkeros-mcp/4.7.0-next-1790187973605";
 function getPackageBaseUrl() {
   return process.env.WALKEROS_APP_URL || void 0;
 }
@@ -24283,9 +24275,10 @@ function registerAddStepPrompt(server) {
               "",
               "Important:",
               "- Read the walkeros://reference/flow-schema resource to understand connection rules.",
-              "- Sources connect to pre-collector transformers via `next`.",
-              "- Destinations connect to post-collector transformers via `before`.",
-              '- Routing supports string IDs, sequences (`["a", "b"]`), or RouteConfig (`{ match?, next }` for gated single-target or `{ match?, one: [...] }` for first-match dispatch). Use `many` (instead of `one`) when every matching entry should run as an independent parallel flow \u2014 restricted to pre-collector positions. Omit `match` for always-match.',
+              "- Sources connect to transformers via `next` (runs before the collector).",
+              "- The collector connects to transformers via `collector.next` (runs once per event before the destination fan-out, for every destination).",
+              "- Destinations connect to transformers via `before` (runs for that destination only; put per-destination filtering here).",
+              '- Routing uses one grammar in every chain field: string IDs, sequences (`["a", "b"]`, where a member\'s own `next` runs right after it), or RouteConfig (`{ match?, next }` for a gated link, `{ match?, one: [...] }` for first-match dispatch, `{ match?, many: [...] }` to fork each match into its own copy that finishes the rest of the path, `{ match?, stop: true }` to drop). A `stop` in `collector.next` drops the event for all destinations. Omit `match` for always-match.',
               "- A transformer entry can be code-bearing (`code`), package-bearing (`package`), or a **pass-through step** (no `code`, no `package`). Pass-through synthesis is automatic at runtime. Three flavors of pass-through: `before`/`next`-only (named hop reusable across destinations), `cache`-only (dedup, rate-limit), or `mapping`-only (declarative event-to-event transform). A pass-through must declare at least one of `before`, `next`, `cache`, or `mapping`.",
               "- The `mapping` field on a transformer step uses the same `Mapping.Config` shape as destinations, but the semantic is event-to-event (mutates the event in place via `policy`, per-rule `policy`, `mapping[].name` for renames, `mapping[].ignore` to drop). Vendor-payload fields (`data`, `silent`) are no-ops at this position.",
               "- Closed schema: unknown top-level keys on a transformer step are errors (catches typos like `dedup` instead of `cache`). `code` + `package` together is a conflict.",
@@ -24424,7 +24417,7 @@ var SERVER_INSTRUCTIONS = `walkerOS is an open-source, privacy-first event data
 
 ## Architecture: Source \u2192 Collector \u2192 Destination(s)
 
-Every component in a flow is a **step**: sources capture events, transformers process them, destinations deliver them, stores provide shared state. Steps connect via \`next\` (pre-collector) and \`before\` (post-collector) chains.
+Every component in a flow is a **step**: sources capture events, transformers process them, destinations deliver them, stores provide shared state. Steps connect via chains: \`source.next\` runs before the collector, \`collector.next\` runs once per event before the destination fan-out (all destinations), and \`destination.before\` runs for one destination.
 
 ## Flow Config Structure
 
@@ -24452,11 +24445,11 @@ Every component in a flow is a **step**: sources capture events, transformers pr
 - **Contracts** define event schemas using entity-action keying. Can generate FROM mappings or scaffold mappings FROM contracts.
 - **Variables** ($var, $env, $secret, $code, $store) enable DRY, environment-aware config. \`$var.name\` is a reusable flow variable from the top-level \`variables\` block; whole-string refs preserve native type (object/array/scalar), inline interpolation requires a scalar, deep paths via \`$var.name.deep.path\`. \`$env.NAME[:default]\` is an environment variable resolved at bundle/deploy time (non-secret config only). \`$secret.NAME\` is a managed secret the deploy pipeline injects into the server runner at runtime; credentials, tokens, and private keys must use \`$secret\`, not \`$env\`.
 - **Consent** gates destinations, mapping rules, and individual fields. Privacy-first by design.
-- **Routing** wires steps via \`next\` (pre-collector) and \`before\` (post-collector). A route is a string ID, a sequence (\`["a", "b"]\`), or a RouteConfig (\`{ match?, next }\` or \`{ match?, one: [...] }\`). The \`one\` operator dispatches first-match against an ordered list of branches. Use \`many\` (instead of \`one\`) when every matching entry should run as an independent parallel flow \u2014 restricted to pre-collector positions. The optional \`match\` field is omitted to mean always-match (no wildcard literal).
+- **Routing** uses one grammar in every chain field (\`source.before\`, \`source.next\`, \`transformer.before\`, \`transformer.next\`, \`collector.next\`, \`destination.before\`, \`destination.next\`). A route is a string ID, a sequence (\`["a", "b"]\`), or a RouteConfig: \`{ match?, next }\`, \`{ match?, one: [...] }\` (first match wins), \`{ match?, many: [...] }\` (every match becomes its own copy of the event with its own id and finishes the rest of the path on its own, never merged), or \`{ match?, stop: true }\` (ends that copy). In a sequence, a member's own \`next\` runs right after it, then the sequence continues. \`match\` reads \`{ ingest, event }\` and each route is evaluated when the event reaches it. A \`stop\` in \`collector.next\` drops the event for every destination; per-destination filtering belongs in \`destination.before\`. An array of only route configs is an implicit \`one\`. The optional \`match\` field is omitted to mean always-match (no wildcard literal).
 - **Pass-through steps** are transformer entries with no \`code\` and no \`package\`. The runtime synthesizes the push for them automatically. Three flavors share this shape: a \`before\` / \`next\`-only step (named hop reusable across destinations), a \`cache\`-only step (dedup, rate-limit), and a \`mapping\`-only step (declarative event-to-event transform). A pass-through must declare at least one of \`before\`, \`next\`, \`cache\`, or \`mapping\`.
 - **Mapping at the transformer position** uses the same \`Mapping.Config\` shape as destinations, but the semantic is event-to-event: \`policy\` and per-rule \`policy\`, \`mapping[].name\` (rename), \`mapping[].ignore\` (drop from chain), \`consent\`, and \`include\` apply. Vendor-payload fields (\`data\`, \`silent\`, \`mapping[].data\`) are no-ops at this position.
 - **Closed-schema rule on transformer entries:** known keys only. Operative keys are \`code\`, \`package\`, \`before\`, \`next\`, \`cache\`, \`mapping\`. Combined with structural keys (\`config\`, \`env\`, \`validate\`, \`disabled\`, \`id\`, etc.). Unknown top-level keys on a transformer step are errors (catches typos like \`dedup: {}\` instead of nested under \`cache\`). \`code\` + \`package\` together is a conflict.
-- **Cache** memoizes step output on a configured store. Set \`cache.stop: true\` to short-circuit the chain on HIT (sources default to stop-on-HIT). Set \`cache.namespace\` to prefix keys; omit it to write keys directly. \`CacheRule.match\` is optional, omit for always-match.
+- **Cache** memoizes step output on a configured store. Set \`cache.stop: true\` to short-circuit the chain on HIT (sources default to stop-on-HIT); in a source chain or \`collector.next\` that halts the event for all destinations. Set \`cache.namespace\` to prefix keys; omit it to write keys directly. \`CacheRule.match\` is optional, omit for always-match.
 
 ## Simulation Tips