@lotics/cli 0.187.1 → 0.188.0

package/dist/src/cli.js

@@ -45875,7 +45875,7 @@ function resultSideEffects(result) {
 }
 
 // src/version.ts
-var VERSION = "0.187.1";
+var VERSION = "0.188.0";
 
 // src/timezone.ts
 function machineTimezone() {
@@ -46584,7 +46584,7 @@ function buildStarterTemplate(args) {
 import { defineConfig } from "vite";
 import type { Plugin } from "vite";
 import react from "@vitejs/plugin-react";
-import { loticsOptimizeDeps, loticsResolve } from "@lotics/ui/vite";
+import { loticsOptimizeDeps, loticsOptimizeExclude, loticsResolve } from "@lotics/ui/vite";
 
 // @lotics/ui/icon.tsx deep-imports \`lucide-react-native/dist/esm/icons/<name>\`.
 // lucide-react-native's \`exports\` map lists only "." and "./icons", so a strict
@@ -46646,6 +46646,11 @@ export default defineConfig({
     // require across a major bump \u2014 the per-family rationale lives in that module.
     // To add app-specific entries, spread: include: [...loticsOptimizeDeps, "my-dep"].
     include: loticsOptimizeDeps,
+    // The kit is ONE module graph, so it must never be pre-bundled: the optimizer
+    // auto-discovers each @lotics/ui subpath and inlines a private copy of every
+    // context-owning module it reaches (locale, tooltip, portal, popover), leaving
+    // the provider filling one context and the component reading another.
+    exclude: loticsOptimizeExclude,
     // The dep optimizer pre-bundles deps with a SEPARATE esbuild pass that
     // top-level \`define\` doesn't always reach, so a pre-bundled RN dep can
     // still hit \`__DEV__ is not defined\` under \`lotics app dev\`. Define it
@@ -66481,10 +66486,9 @@ var pathSegmentSchema = zod_default.discriminatedUnion("at", [
     at: zod_default.literal("linked"),
     via: zod_default.string().min(1),
     /**
-     * `number` — pick a single linked record by literal index.
-     * `"each"` — fan out; legal only inside foreach.items (validator-enforced).
-     * `WorkflowExpression` — computed index, resolved at runtime to pick a
-     * single linked record (same descent semantics as the numeric form).
+     * Which linked rows the fetch yields. A literal or computed index picks
+     * one row — `linked(P)[i]`, one fetch. `"each"` is the bare `linked(P)`:
+     * every row in order, holding a `null` where one is deleted or unreadable.
      */
     index: zod_default.union([
       zod_default.number().int().nonnegative(),
@@ -68970,6 +68974,8 @@ var RESERVED_ROOTS = /* @__PURE__ */ new Set([
   "trigger",
   "index"
 ]);
+var LINKED_CALL = "linked";
+var GRAMMAR_NAME_SHAPE = `${LINKED_CALL}(record["fld_link"])[0] fetches one linked row`;
 var RUNTIME_KEYS = /* @__PURE__ */ new Set([
   "timezone",
   "workflow_id",
@@ -69159,6 +69165,30 @@ var RESERVED_CALLABLE_NAMES = /* @__PURE__ */ new Set([
   "Math",
   "Boolean"
 ]);
+function assertNotReservedName(node, name2, label, toolNames) {
+  if (RESERVED_ROOTS.has(name2)) {
+    fail(node, `${label} uses the reserved identifier "${name2}".`);
+  }
+  if (name2 === LINKED_CALL) {
+    fail(node, `${label} names grammar: ${GRAMMAR_NAME_SHAPE}.`, "reserved_grammar_name");
+  }
+  if (toolNames?.has(name2)) {
+    fail(node, `${label} collides with the tool "${name2}".`);
+  }
+  if (isHelper(name2)) {
+    fail(node, `${label} collides with the built-in helper "${name2}".`);
+  }
+  if (RESERVED_CALLABLE_NAMES.has(name2)) {
+    fail(node, `${label} collides with "${name2}", which the subset already gives a meaning.`);
+  }
+}
+var LINKED_ARITY = `${LINKED_CALL}(...) takes exactly one argument \u2014 the read of the link field, e.g. ${LINKED_CALL}(record["fld_link"])[0] for one row or ${LINKED_CALL}(record["fld_link"]) for every row.`;
+var LINKED_ARGUMENT_SHAPE = `The argument of ${LINKED_CALL}(...) must END on the link field, because that field is what it follows \u2014 ${LINKED_CALL}(record["fld_link"])[0]. A value that names no field (a binding, a literal, a helper result) cannot say which link to follow; read the field on it: ${LINKED_CALL}(ids["fld_link"]).`;
+var LINKED_OPTIONAL_RESULT = `${LINKED_CALL}(...) always returns an array, never null, so \`?.\` on its result can never fire. The argument takes a guard \u2014 ${LINKED_CALL}(record?.["fld_link"])[0] \u2014 and so does the fetched row, which is null where the linked record is deleted or unreadable: ${LINKED_CALL}(record["fld_link"])[0]?.["fld_x"].`;
+var LINKED_METHOD_FORM = `${LINKED_CALL} has no method form \u2014 write ${LINKED_CALL}(record["fld_link"])[0], with the link read as the argument.`;
+var LINKED_ON_NON_RECORD = `${LINKED_CALL}(...) follows a link field on a record, and this value is not one. Read the record first, then follow the link: ${LINKED_CALL}(record["fld_link"])[0].`;
+var LINKED_ON_CHANGES = `A change diff is not a record, so ${LINKED_CALL}(...) cannot follow a link off it. Read the post-state with ${LINKED_CALL}(record["fld_link"]) or the pre-state with ${LINKED_CALL}(prev_record["fld_link"]).`;
+var OPTIONAL_CALL_MESSAGE = "Optional calls (`x?.()`) are not supported. Use `?.` on member access only.";
 var MAX_EXPRESSION_DEPTH = 500;
 function walkExpression(node, scope) {
   const depth = scope.depth + 1;
@@ -69405,11 +69435,10 @@ function walkHelperCall(node, scope) {
     fail(callee, LAMBDA_POSITION_HINT, "lambda_position");
   }
   if (node.type === "OptionalCallExpression" && node.optional === true) {
-    fail(
-      node,
-      "Optional calls (`x?.()`) are not supported. Use `?.` on member access only.",
-      "optional_call"
-    );
+    fail(node, OPTIONAL_CALL_MESSAGE, "optional_call");
+  }
+  if (callee.type === "Identifier" && callee.name === LINKED_CALL) {
+    return walkRead(node, scope);
   }
   if ((callee.type === "MemberExpression" || callee.type === "OptionalMemberExpression") && callee.object.type === "Identifier" && callee.object.name === "Math" && !callee.computed && callee.property.type === "Identifier") {
     const mathFn = callee.property.name;
@@ -69486,6 +69515,9 @@ function walkMethodForm(node, callee, scope) {
     }
     methodName = callee.property.name;
   }
+  if (methodName === LINKED_CALL) {
+    fail(callee, LINKED_METHOD_FORM, "linked_method_form");
+  }
   const receiver = walkExpression(callee.object, scope);
   const methodOptional = callee.type === "OptionalMemberExpression" && callee.optional === true;
   const liftedGuards = [];
@@ -69612,12 +69644,7 @@ function walkLambda(node, scope) {
     if (p.type !== "Identifier") {
       fail(p, "Lambda parameters must be plain identifiers (no destructuring or defaults).");
     }
-    if (RESERVED_ROOTS.has(p.name)) {
-      fail(p, `${p.name} is reserved and cannot be a lambda parameter.`);
-    }
-    if (scope.toolNames.has(p.name) || isHelper(p.name)) {
-      fail(p, `Lambda parameter "${p.name}" collides with a tool or helper.`);
-    }
+    assertNotReservedName(p, p.name, `Lambda parameter "${p.name}"`, scope.toolNames);
     if (scope.functions.has(p.name)) {
       fail(p, `Lambda parameter "${p.name}" collides with a function declared in this workflow.`);
     }
@@ -69690,7 +69717,7 @@ function collectFunctionDeclarations(body, toolNames) {
       failFunctionDeclaration(stmt, "A function declaration must be named.");
     }
     const name2 = stmt.id.name;
-    assertFunctionName(stmt.id, name2, `Function "${name2}"`, toolNames);
+    assertNotReservedName(stmt.id, name2, `Function "${name2}"`, toolNames);
     if (functions.has(name2)) {
       fail(stmt.id, `Function "${name2}" is already declared in this workflow.`);
     }
@@ -69712,7 +69739,7 @@ function collectFunctionDeclarations(body, toolNames) {
         );
       }
       const paramName = p.left.name;
-      assertFunctionName(p.left, paramName, `Parameter "${paramName}"`, toolNames);
+      assertNotReservedName(p.left, paramName, `Parameter "${paramName}"`, toolNames);
       if (seen.has(paramName)) {
         fail(p.left, `Parameter "${paramName}" of function "${name2}" is declared twice.`);
       }
@@ -69738,20 +69765,6 @@ function collectFunctionDeclarations(body, toolNames) {
   }
   return functions;
 }
-function assertFunctionName(node, name2, label, toolNames) {
-  if (RESERVED_ROOTS.has(name2)) {
-    fail(node, `${label} uses the reserved identifier "${name2}".`);
-  }
-  if (toolNames.has(name2)) {
-    fail(node, `${label} collides with the tool "${name2}".`);
-  }
-  if (isHelper(name2)) {
-    fail(node, `${label} collides with the built-in helper "${name2}".`);
-  }
-  if (RESERVED_CALLABLE_NAMES.has(name2)) {
-    fail(node, `${label} collides with "${name2}", which the subset already gives a meaning.`);
-  }
-}
 function inlineFunctionCall(node, decl, scope) {
   if (scope.inline.stack.includes(decl.name)) {
     fail(
@@ -69806,6 +69819,7 @@ function functionBodyScope(scope, name2, args) {
     depth: scope.depth
   };
 }
+var READ_ROOT_HINT = `Reads must start from a reserved identifier (record, prev_record, changes, runtime, trigger, index), a foreach bind name, a step-id, or ${LINKED_CALL}(record["fld_link"]).`;
 function flattenChain(node, scope) {
   let cur = node;
   const reverse2 = [];
@@ -69845,8 +69859,11 @@ function flattenChain(node, scope) {
     }
     cur = cur.object;
   }
+  if (cur.type === "CallExpression" || cur.type === "OptionalCallExpression") {
+    return flattenLinkedCall(cur, reverse2, scope);
+  }
   if (cur.type !== "Identifier") {
-    fail(cur, "Reads must start from a reserved identifier (record, prev_record, changes, runtime, trigger, index), a foreach bind name, or a step-id.");
+    fail(cur, READ_ROOT_HINT, "read_root");
   }
   return {
     rootName: cur.name,
@@ -69854,6 +69871,58 @@ function flattenChain(node, scope) {
     segments: reverse2.reverse()
   };
 }
+function flattenLinkedCall(node, reverse2, scope) {
+  const callee = node.callee;
+  if ((callee.type === "MemberExpression" || callee.type === "OptionalMemberExpression") && (!callee.computed && callee.property.type === "Identifier" && callee.property.name === LINKED_CALL || callee.computed && callee.property.type === "StringLiteral" && callee.property.value === LINKED_CALL)) {
+    fail(callee, LINKED_METHOD_FORM, "linked_method_form");
+  }
+  if (callee.type !== "Identifier" || callee.name !== LINKED_CALL) {
+    fail(node, READ_ROOT_HINT, "read_root");
+  }
+  if (node.type === "OptionalCallExpression" && node.optional === true) {
+    fail(node, OPTIONAL_CALL_MESSAGE, "optional_call");
+  }
+  if (node.arguments.length !== 1) {
+    fail(node, LINKED_ARITY, "linked_arity");
+  }
+  const arg = node.arguments[0];
+  if (arg.type !== "MemberExpression" && arg.type !== "OptionalMemberExpression") {
+    fail(arg, LINKED_ARGUMENT_SHAPE, "linked_argument_shape");
+  }
+  const onResult = reverse2[reverse2.length - 1];
+  if (onResult?.optional === true) {
+    fail(onResult.node, LINKED_OPTIONAL_RESULT, "linked_optional_result");
+  }
+  const folded = onResult?.kind === "bracket-number" ? onResult.index : onResult?.kind === "bracket-expr" ? onResult.expr : void 0;
+  const linkedIndex = folded ?? "each";
+  const afterCall = folded === void 0 ? reverse2 : reverse2.slice(0, -1);
+  const argScope = { ...scope, depth: scope.depth + 1 };
+  if (argScope.depth > MAX_EXPRESSION_DEPTH) {
+    fail(node, `Expression nesting is too deep (max ${MAX_EXPRESSION_DEPTH} levels).`, "depth_limit");
+  }
+  const inner = flattenChain(arg, argScope);
+  const via = inner.segments[inner.segments.length - 1];
+  if (!via || via.kind !== "dot" && via.kind !== "bracket-string") {
+    fail(arg, LINKED_ARGUMENT_SHAPE, "linked_argument_shape");
+  }
+  return {
+    rootName: inner.rootName,
+    rootNode: inner.rootNode,
+    segments: [
+      ...inner.segments.slice(0, -1),
+      // `linked(record?.["fld_link"])` guards the RECEIVER of the link read, so
+      // the guard belongs on the segment the call became.
+      {
+        kind: "linked",
+        via: via.key,
+        index: linkedIndex,
+        optional: via.optional === true,
+        node: arg
+      },
+      ...[...afterCall].reverse()
+    ]
+  };
+}
 function wrapOptionalGuards(chain2, buildRead) {
   const firstOpt = chain2.segments.findIndex((s) => s.optional);
   if (firstOpt === -1) return buildRead(chain2.segments);
@@ -69916,7 +69985,7 @@ function walkRead(node, scope) {
     const base = inlined;
     return wrapOptionalGuards(chain2, (segments) => ({
       ...base,
-      path: [...base.path, ...classifyRecordPath(segments)]
+      path: [...base.path, ...pathFor(base.source, segments)]
     }));
   }
   if (root === "record" || root === "prev_record") {
@@ -69983,19 +70052,20 @@ function walkRead(node, scope) {
   );
 }
 function readFromRecord(from, chain2) {
+  const root = from === "trigger_record" ? "record" : "prev_record";
   return wrapOptionalGuards(chain2, (segments) => {
     if (segments.length === 0) {
       return { kind: "read", source: { from }, path: [] };
     }
     const first3 = segments[0];
     if (first3.kind === "bracket-number" || first3.kind === "bracket-expr") {
-      fail(first3.node, "Field access uses string keys. For linked records use record.LinkedField[0].");
+      fail(
+        first3.node,
+        `A record is keyed by field, not by index \u2014 ${root}["fld_\u2026"]. To fetch a linked row write ${LINKED_CALL}(${root}["fld_link"])[0].`
+      );
     }
-    return {
-      kind: "read",
-      source: { from },
-      path: classifyRecordPath(segments)
-    };
+    const source = { from };
+    return { kind: "read", source, path: pathFor(source, segments) };
   });
 }
 function readFromChanges(chain2) {
@@ -70007,17 +70077,8 @@ function readFromChanges(chain2) {
     if (first3.kind === "bracket-number" || first3.kind === "bracket-expr") {
       fail(first3.node, "changes is keyed by field name, not numeric index.");
     }
-    const path13 = [{ at: "key", key: first3.key }];
-    for (const seg of segments.slice(1)) {
-      if (seg.kind === "bracket-number") {
-        path13.push({ at: "index", index: seg.index });
-      } else if (seg.kind === "bracket-expr") {
-        path13.push({ at: "index", index: seg.expr });
-      } else {
-        path13.push({ at: "key", key: seg.key });
-      }
-    }
-    return { kind: "read", source: { from: "trigger_changes" }, path: path13 };
+    const source = { from: "trigger_changes" };
+    return { kind: "read", source, path: pathFor(source, segments) };
   });
 }
 var TRIGGER_RECORD_VIEWS = /* @__PURE__ */ new Map([
@@ -70035,17 +70096,8 @@ function readFromTrigger(chain2) {
     return view === "trigger_changes" ? readFromChanges(lowered) : readFromRecord(view, lowered);
   }
   return wrapOptionalGuards(chain2, (segments) => {
-    const path13 = [];
-    for (const seg of segments) {
-      if (seg.kind === "bracket-number") {
-        path13.push({ at: "index", index: seg.index });
-      } else if (seg.kind === "bracket-expr") {
-        path13.push({ at: "index", index: seg.expr });
-      } else {
-        path13.push({ at: "key", key: seg.key });
-      }
-    }
-    return { kind: "read", source: { from: "trigger" }, path: path13 };
+    const source = { from: "trigger" };
+    return { kind: "read", source, path: pathFor(source, segments) };
   });
 }
 function readFromRuntime(chain2) {
@@ -70057,112 +70109,79 @@ function readFromRuntime(chain2) {
       fail(chain2.rootNode, "runtime needs a key (e.g., runtime.timezone).");
     }
     const first3 = segments[0];
+    if (first3.kind === "linked") {
+      fail(first3.node, LINKED_ON_NON_RECORD, "linked_on_non_record");
+    }
     if (first3.kind !== "dot" && first3.kind !== "bracket-string") {
       fail(first3.node, "runtime is keyed by name (runtime.timezone, runtime.now, ...).");
     }
-    const key = first3.key ?? "";
+    const key = first3.key;
     if (!isRuntimeKey(key)) {
       fail(first3.node, `Unknown runtime key "${key}". Allowed: ${READABLE_RUNTIME_KEYS.join(", ")}.`);
     }
     const parked = PARKED_RUNTIME_KEYS.get(key);
     if (parked) fail(first3.node, parked, parkedRuntimeKeyConstruct(key));
     const source = { from: "runtime", key };
-    const path13 = [];
-    for (const seg of segments.slice(1)) {
-      if (seg.kind === "bracket-number") {
-        path13.push({ at: "index", index: seg.index });
-      } else if (seg.kind === "bracket-expr") {
-        path13.push({ at: "index", index: seg.expr });
-      } else {
-        path13.push({ at: "key", key: seg.key });
-      }
-    }
-    return { kind: "read", source, path: path13 };
+    return { kind: "read", source, path: pathFor(source, segments.slice(1)) };
   });
 }
 function readFromForeachItem(name2, chain2) {
-  return wrapOptionalGuards(chain2, (segments) => ({
-    kind: "read",
-    // NAMED, so a read inside a nested loop says which loop it means. Without
-    // it both binds resolved to the innermost item, and a join between two
-    // collections matched nothing while the workflow reported success.
-    source: { from: "foreach_item", name: name2 },
-    path: classifyRecordPath(segments)
-  }));
+  return wrapOptionalGuards(chain2, (segments) => {
+    const source = { from: "foreach_item", name: name2 };
+    return { kind: "read", source, path: pathFor(source, segments) };
+  });
 }
 function readFromLambdaParam(name2, chain2) {
-  return wrapOptionalGuards(chain2, (segments) => ({
-    kind: "read",
-    source: { from: "lambda_param", name: name2 },
-    // Lambda params commonly hold records iterated from an array (`filter`,
-    // `find`, `sortBy`), so use the same path classifier as foreach_item:
-    // `x.Field` is a key/field read, `x.LinkedField[0]` collapses to a
-    // `linked` segment. The resolver promotes `at: "key"` → `at: "field"`
-    // when it can infer the param's table from the enclosing helper call.
-    path: classifyRecordPath(segments)
-  }));
+  return wrapOptionalGuards(chain2, (segments) => {
+    const source = { from: "lambda_param", name: name2 };
+    return { kind: "read", source, path: pathFor(source, segments) };
+  });
 }
 function readFromLexical(name2, chain2) {
   return wrapOptionalGuards(chain2, (segments) => {
-    if (segments.length === 0) {
-      return { kind: "read", source: { from: "lexical", name: name2 }, path: [] };
-    }
-    return {
-      kind: "read",
-      source: { from: "lexical", name: name2 },
-      path: classifyRecordPath(segments)
-    };
+    const source = { from: "lexical", name: name2 };
+    return { kind: "read", source, path: pathFor(source, segments) };
   });
 }
 function readFromStepOutput(stepId, chain2) {
   return wrapOptionalGuards(chain2, (segments) => {
-    const path13 = [];
-    for (const seg of segments) {
-      if (seg.kind === "bracket-number") {
-        path13.push({ at: "index", index: seg.index });
-      } else if (seg.kind === "bracket-expr") {
-        path13.push({ at: "index", index: seg.expr });
-      } else {
-        path13.push({ at: "key", key: seg.key });
-      }
-    }
-    return { kind: "read", source: { from: "step_output", step_id: stepId }, path: path13 };
+    const source = { from: "step_output", step_id: stepId };
+    return { kind: "read", source, path: pathFor(source, segments) };
   });
 }
-function classifyRecordPath(segs) {
-  const out = [];
-  let i2 = 0;
-  while (i2 < segs.length) {
-    const seg = segs[i2];
-    if (seg.kind === "bracket-number") {
-      out.push({ at: "index", index: seg.index });
-      i2 += 1;
-      continue;
-    }
-    if (seg.kind === "bracket-expr") {
-      out.push({ at: "index", index: seg.expr });
-      i2 += 1;
-      continue;
-    }
-    const name2 = seg.key;
-    const next = segs[i2 + 1];
-    if (next && next.kind === "bracket-number") {
-      out.push({ at: "linked", via: name2, index: next.index });
-      i2 += 2;
-      continue;
-    }
-    if (next && next.kind === "bracket-expr") {
-      out.push({ at: "linked", via: name2, index: next.expr });
-      i2 += 2;
-      continue;
+var LINKED_REFUSAL = {
+  trigger_record: null,
+  trigger_record_prev: null,
+  foreach_item: null,
+  lambda_param: null,
+  lexical: null,
+  step_output: null,
+  trigger: LINKED_ON_NON_RECORD,
+  trigger_changes: LINKED_ON_CHANGES,
+  runtime: LINKED_ON_NON_RECORD,
+  foreach_index: LINKED_ON_NON_RECORD
+};
+function pathFor(source, segs) {
+  const refusal = LINKED_REFUSAL[source.from];
+  return segs.map((seg) => {
+    switch (seg.kind) {
+      case "bracket-number":
+        return { at: "index", index: seg.index };
+      case "bracket-expr":
+        return { at: "index", index: seg.expr };
+      case "linked":
+        if (refusal !== null) fail(seg.node, refusal, "linked_on_non_record");
+        return { at: "linked", via: seg.via, index: seg.index };
+      case "dot":
+      case "bracket-string":
+        return { at: "key", key: seg.key };
     }
-    out.push({ at: "key", key: name2 });
-    i2 += 1;
-  }
-  return out;
+  });
 }
 
 // ../shared/src/parse_workflow_js.ts
+var LINKED_STATEMENT = `${LINKED_CALL}(...) reads linked rows; it is not a step. Iterate them \u2014 for (const r of ${LINKED_CALL}(record["fld_link"])) { ... } \u2014 or index one: ${LINKED_CALL}(record["fld_link"])[0]["fld_x"].`;
+var LINKED_AWAIT = `${LINKED_CALL}(...) is grammar, not a tool, and takes no await \u2014 it reads linked rows in place. Write ${LINKED_CALL}(record["fld_link"])[0]["fld_x"], or iterate them: for (const r of ${LINKED_CALL}(record["fld_link"])) { ... }.`;
 var MAX_SOURCE_LENGTH = 512 * 1024;
 function checkSourceLength(source) {
   if (source.length > MAX_SOURCE_LENGTH) {
@@ -70301,6 +70320,7 @@ function walkStatement(stmt, scope, stepIds, opts, nextSyntheticId, depth) {
 function walkStatementInner(stmt, scope, stepIds, opts, nextSyntheticId, depth) {
   const { id: explicitId, description } = readLeadingComments(stmt);
   if (explicitId !== void 0) {
+    assertNotReservedName(stmt, explicitId, `Step id "${explicitId}"`, opts.toolNames);
     assertNoFunctionCollision(stmt, explicitId, scope, "Step id");
   }
   switch (stmt.type) {
@@ -70422,12 +70442,7 @@ function walkConstDeclarator(decl, scope, stepIds, opts, explicitId, description
     fail(decl.id, "Bindings must use an identifier or `{ ... }` / `[ ... ]` destructuring.");
   }
   const id = decl.id.name;
-  if (RESERVED_ROOTS.has(id)) {
-    fail(decl.id, `${id} is reserved.`);
-  }
-  if (opts.toolNames && opts.toolNames.has(id) || isHelper(id)) {
-    fail(decl.id, `Cannot bind to "${id}" \u2014 name collides with a tool or helper.`);
-  }
+  assertNotReservedName(decl.id, id, `Binding "${id}"`, opts.toolNames);
   assertNoFunctionCollision(decl.id, id, scope, "Binding");
   if (stepIds.has(id)) {
     fail(decl.id, `Step id "${id}" is already used.`);
@@ -70599,12 +70614,7 @@ function walkPatternBinding(decl, scope, stepIds, opts, explicitId, description,
     makeBase = (segment) => ({ ...rhs, path: [...rhs.path, segment] });
   }
   for (const entry of walkPatternEntries(pattern, scope)) {
-    if (RESERVED_ROOTS.has(entry.name)) {
-      fail(entry.node, `${entry.name} is reserved.`);
-    }
-    if (opts.toolNames && opts.toolNames.has(entry.name) || isHelper(entry.name)) {
-      fail(entry.node, `Cannot bind to "${entry.name}" \u2014 name collides with a tool or helper.`);
-    }
+    assertNotReservedName(entry.node, entry.name, `Binding "${entry.name}"`, opts.toolNames);
     assertNoFunctionCollision(entry.node, entry.name, scope, "Binding");
     if (stepIds.has(entry.name)) {
       fail(entry.node, `Step id "${entry.name}" is already used.`);
@@ -70643,12 +70653,7 @@ function walkLetDeclaration(stmt, scope, stepIds, opts, explicitId, description)
       const frame = scope.lexicalBindings[scope.lexicalBindings.length - 1];
       for (const entry of walkPatternEntries(decl.id, scope)) {
         const name3 = entry.name;
-        if (RESERVED_ROOTS.has(name3)) {
-          fail(entry.node, `${name3} is reserved and cannot be a let binding name.`);
-        }
-        if (opts.toolNames && opts.toolNames.has(name3) || isHelper(name3)) {
-          fail(entry.node, `let binding "${name3}" collides with a tool or helper.`);
-        }
+        assertNotReservedName(entry.node, name3, `let binding "${name3}"`, opts.toolNames);
         assertNoFunctionCollision(entry.node, name3, scope, "let binding");
         if (stepIds.has(name3)) {
           fail(entry.node, `let binding "${name3}" collides with a step id.`);
@@ -70674,12 +70679,7 @@ function walkLetDeclaration(stmt, scope, stepIds, opts, explicitId, description)
       fail(decl.id, "let bindings require a plain identifier name.");
     }
     const name2 = decl.id.name;
-    if (RESERVED_ROOTS.has(name2)) {
-      fail(decl.id, `${name2} is reserved and cannot be a let binding name.`);
-    }
-    if (opts.toolNames && opts.toolNames.has(name2) || isHelper(name2)) {
-      fail(decl.id, `let binding "${name2}" collides with a tool or helper.`);
-    }
+    assertNotReservedName(decl.id, name2, `let binding "${name2}"`, opts.toolNames);
     assertNoFunctionCollision(decl.id, name2, scope, "let binding");
     if (stepIds.has(name2)) {
       fail(decl.id, `let binding "${name2}" collides with a step id.`);
@@ -70726,24 +70726,21 @@ function walkExpressionStatement(stmt, scope, stepIds, opts, stepId, description
       stepIds.add(stepId);
       return walkAgentInvocation(inner, scope, stepId, description);
     }
-    if (!opts.toolNames || opts.toolNames.has(name2)) {
-      const { tool_name, input } = walkToolInvocation(
-        inner,
-        scope,
-        opts,
-        /*allowWaits*/
-        true
-      );
-      stepIds.add(stepId);
-      return {
-        id: stepId,
-        description: description ?? tool_name,
-        type: "tool_call",
-        tool_name,
-        input
-      };
-    }
-    fail(callee, unknownToolMessage(name2, opts.toolNames) + " Tools must be registered.");
+    const { tool_name, input } = walkToolInvocation(
+      inner,
+      scope,
+      opts,
+      /*allowWaits*/
+      true
+    );
+    stepIds.add(stepId);
+    return {
+      id: stepId,
+      description: description ?? tool_name,
+      type: "tool_call",
+      tool_name,
+      input
+    };
   }
   if (e.type === "CallExpression" && e.callee.type === "MemberExpression" && !e.callee.computed && e.callee.property.type === "Identifier" && e.callee.property.name === "push") {
     return walkPushStatement(e, scope, stepId, description);
@@ -70767,6 +70764,9 @@ function walkExpressionStatement(stmt, scope, stepIds, opts, stepId, description
     if (callee.type === "Identifier" && WAIT_TOOLS.has(callee.name)) {
       fail(e, `${callee.name} must be awaited: write "await ${callee.name}({...})".`);
     }
+    if (callee.type === "Identifier" && callee.name === LINKED_CALL) {
+      fail(e, LINKED_STATEMENT, "linked_statement");
+    }
     if (callee.type === "Identifier" && isHelper(callee.name)) {
       fail(e, `Helpers may only appear inside expressions, not as standalone statements.`);
     }
@@ -70789,9 +70789,7 @@ function walkAssignmentStatement(e, scope, stepId, description) {
     fail(e.left, "Assignment targets must be a plain identifier referring to a `let` binding.");
   }
   const name2 = e.left.name;
-  if (RESERVED_ROOTS.has(name2)) {
-    fail(e.left, `${name2} is reserved and cannot be reassigned.`);
-  }
+  assertNotReservedName(e.left, name2, `Assignment target "${name2}"`, scope.toolNames);
   if (!findLexicalBinding(scope, name2)) {
     fail(e.left, `Cannot assign to "${name2}" \u2014 no enclosing \`let\` declaration in scope.`);
   }
@@ -70824,9 +70822,7 @@ function walkUpdateStatement(e, scope, stepId, description) {
     fail(e.argument, "Update operators (++/--) require a plain identifier referring to a `let` binding.");
   }
   const name2 = e.argument.name;
-  if (RESERVED_ROOTS.has(name2)) {
-    fail(e.argument, `${name2} is reserved.`);
-  }
+  assertNotReservedName(e.argument, name2, `Update target "${name2}"`, scope.toolNames);
   if (!findLexicalBinding(scope, name2)) {
     fail(e.argument, `Cannot update "${name2}" \u2014 no enclosing \`let\` declaration in scope.`);
   }
@@ -71002,17 +70998,12 @@ function walkForOf(stmt, scope, stepIds, opts, stepId, description, nextSyntheti
   } else {
     fail(decl.id, "for-of must bind an identifier or a `{ ... }` / `[ ... ]` pattern.");
   }
-  if (RESERVED_ROOTS.has(bindName) && bindName !== "item") {
-    fail(decl.id, `${bindName} is reserved and cannot be a foreach bind name.`);
-  }
+  assertNotReservedName(decl.id, bindName, `Foreach bind name "${bindName}"`, opts.toolNames);
   if (stepIds.has(bindName)) {
     fail(decl.id, `Foreach bind name "${bindName}" collides with a step id.`);
   }
-  if (opts.toolNames && opts.toolNames.has(bindName) || isHelper(bindName)) {
-    fail(decl.id, `Foreach bind name "${bindName}" collides with a tool or helper.`);
-  }
   assertNoFunctionCollision(decl.id, bindName, scope, "Foreach bind name");
-  const items = walkForOfRight(stmt.right, scope);
+  const items = walkExpression(stmt.right, scope);
   const innerScope = {
     ...scope,
     foreachBinds: [...scope.foreachBinds, bindName],
@@ -71025,12 +71016,7 @@ function walkForOf(stmt, scope, stepIds, opts, stepId, description, nextSyntheti
   const innerSteps = [];
   if (patternEntries) {
     for (const entry of patternEntries) {
-      if (RESERVED_ROOTS.has(entry.name)) {
-        fail(entry.node, `${entry.name} is reserved.`);
-      }
-      if (opts.toolNames && opts.toolNames.has(entry.name) || isHelper(entry.name)) {
-        fail(entry.node, `Cannot bind to "${entry.name}" \u2014 name collides with a tool or helper.`);
-      }
+      assertNotReservedName(entry.node, entry.name, `Binding "${entry.name}"`, opts.toolNames);
       assertNoFunctionCollision(entry.node, entry.name, scope, "Binding");
       if (stepIds.has(entry.name)) {
         fail(entry.node, `Step id "${entry.name}" is already used.`);
@@ -71067,9 +71053,6 @@ function walkForOf(stmt, scope, stepIds, opts, stepId, description, nextSyntheti
     steps: innerSteps
   };
 }
-function walkForOfRight(node, scope) {
-  return walkExpression(node, scope);
-}
 function walkWhile(stmt, scope, stepIds, opts, stepId, description, nextSyntheticId, depth) {
   if (stmt.body.type !== "BlockStatement") {
     fail(stmt.body, "while body must be a { ... } block.");
@@ -71212,12 +71195,7 @@ function walkTry(stmt, scope, stepIds, opts, stepId, description, nextSyntheticI
     fail(handler.param, "Catch parameter must be a plain identifier.");
   }
   const errorBinding = handler.param.name;
-  if (RESERVED_ROOTS.has(errorBinding)) {
-    fail(handler.param, `${errorBinding} is reserved and cannot be a catch binding.`);
-  }
-  if (opts.toolNames && opts.toolNames.has(errorBinding) || isHelper(errorBinding)) {
-    fail(handler.param, `Catch binding "${errorBinding}" collides with a tool or helper.`);
-  }
+  assertNotReservedName(handler.param, errorBinding, `Catch binding "${errorBinding}"`, opts.toolNames);
   assertNoFunctionCollision(handler.param, errorBinding, scope, "Catch binding");
   if (stepIds.has(errorBinding)) {
     fail(handler.param, `Catch binding "${errorBinding}" collides with an existing step id.`);
@@ -71407,6 +71385,9 @@ function walkToolInvocation(call, scope, opts, allowWaits) {
   if (allowWaits && WAIT_TOOLS.has(name2)) {
     fail(call, `${name2} is a wait step, not a tool. Use "await ${name2}({...})" as a standalone statement.`);
   }
+  if (name2 === LINKED_CALL) {
+    fail(call, LINKED_AWAIT, "linked_statement");
+  }
   if (opts.toolNames && !opts.toolNames.has(name2)) {
     fail(callee, unknownToolMessage(name2, opts.toolNames));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/cli",
-  "version": "0.187.1",
+  "version": "0.188.0",
   "description": "Lotics SDK and CLI for AI agents",
   "type": "module",
   "bin": {