@uicast/core 0.0.1-beta.1 → 0.0.1

package/dist/url-policy.js

@@ -0,0 +1,252 @@
+import { isSchemaObject, resolvePointer } from "./json-schema.js";
+// The defaults, in one place: the check applies them and the prompt describes them.
+export const resolveUrlPolicy = (policy = {}) => {
+    const { allowRelative = true, allowSameOrigin = true, hosts = [], allowDataImages = true, origin } = policy;
+    return { allowRelative, allowSameOrigin, hosts, allowDataImages, origin };
+};
+const OK = { ok: true };
+// Never fetch on their own.
+const INERT_SCHEMES = new Set(["mailto", "tel", "sms", "blob"]);
+// No `svg+xml`: SVG can carry script.
+const DATA_IMAGE_RE = /^data:image\/(png|jpe?g|gif|webp|avif|bmp|x-icon|vnd\.microsoft\.icon)[;,]/i;
+const SCHEME_RE = /^([a-z][a-z0-9+.-]*):/i;
+// For http(s) the URL parser reads `\` as `/`, so a value with no scheme names a host exactly when it starts with two.
+const NAMES_HOST_RE = /^[\\/]{2}/;
+// Supplies only the scheme: a value that names a host keeps its own.
+const NETWORK_PATH_BASE = "https://base.invalid/";
+// Strip what the URL parser strips, or `"java\nscript:"` reads as relative here and `javascript:` in the DOM.
+const normalize = (raw) => {
+    const url = raw.replace(/[\t\n\r]/g, "");
+    // A loop, not a regex: a trailing `[\0- ]+$` takes quadratic time on a long run of spaces.
+    let start = 0;
+    let end = url.length;
+    while (start < end && url.charCodeAt(start) <= 0x20)
+        start++;
+    while (end > start && url.charCodeAt(end - 1) <= 0x20)
+        end--;
+    return url.slice(start, end);
+};
+const parseUrl = (url, base) => {
+    try {
+        return new URL(url, base);
+    }
+    catch {
+        return null;
+    }
+};
+const hostAllowed = (host, hosts) => {
+    const lower = host.toLowerCase();
+    return hosts.some((entry) => {
+        const pattern = entry.toLowerCase();
+        if (pattern.startsWith("*.")) {
+            return lower.endsWith(pattern.slice(1)) && lower !== pattern.slice(2);
+        }
+        return lower === pattern;
+    });
+};
+// Parsed once per string: an explicit origin with a path or a trailing slash still names its origin.
+const explicitOrigins = new Map();
+const currentOrigin = (explicit) => {
+    if (!explicit)
+        return typeof location !== "undefined" ? location.origin : null;
+    let origin = explicitOrigins.get(explicit);
+    if (origin === undefined) {
+        origin = parseUrl(explicit)?.origin ?? null;
+        explicitOrigins.set(explicit, origin);
+    }
+    return origin;
+};
+const checkHost = (url, allowSameOrigin, explicitOrigin, hosts) => {
+    if (allowSameOrigin && url.origin === currentOrigin(explicitOrigin))
+        return OK;
+    if (hosts.length && hostAllowed(url.hostname, hosts))
+        return OK;
+    return {
+        ok: false,
+        reason: `"${url.hostname}" is not an allowed host. Add it to the renderer's ` +
+            `urlPolicy ({ hosts: ["${url.hostname}"] }) if this destination is trusted`,
+    };
+};
+// An empty string passes: nothing to fetch.
+export const checkUrl = (value, policy) => {
+    const url = normalize(value);
+    if (!url)
+        return OK;
+    if (typeof policy === "function") {
+        return policy(url) ? OK : { ok: false, reason: "rejected by the host's urlPolicy predicate" };
+    }
+    const { allowRelative, allowSameOrigin, hosts, allowDataImages, origin: explicitOrigin } = resolveUrlPolicy(policy);
+    const scheme = SCHEME_RE.exec(url)?.[1]?.toLowerCase() ?? null;
+    if (scheme === null) {
+        if (NAMES_HOST_RE.test(url)) {
+            const resolved = parseUrl(url, NETWORK_PATH_BASE);
+            if (!resolved)
+                return { ok: false, reason: "not a parseable URL" };
+            return checkHost(resolved, allowSameOrigin, explicitOrigin, hosts);
+        }
+        return allowRelative ? OK : { ok: false, reason: "relative URLs are not allowed by this urlPolicy" };
+    }
+    if (scheme === "data") {
+        if (allowDataImages && DATA_IMAGE_RE.test(url))
+            return OK;
+        return {
+            ok: false,
+            reason: DATA_IMAGE_RE.test(url)
+                ? "data: URLs are not allowed by this urlPolicy"
+                : 'only "data:image/<raster>" URLs are allowed (svg+xml can carry script)',
+        };
+    }
+    if (INERT_SCHEMES.has(scheme))
+        return OK;
+    if (scheme !== "http" && scheme !== "https") {
+        return { ok: false, reason: `the "${scheme}:" scheme is not allowed` };
+    }
+    const parsed = parseUrl(url);
+    if (!parsed)
+        return { ok: false, reason: "not a parseable absolute URL" };
+    return checkHost(parsed, allowSameOrigin, explicitOrigin, hosts);
+};
+const URL_FORMATS = new Set(["uri", "url", "uri-reference", "iri", "iri-reference"]);
+const hasUrlFormat = (node) => {
+    const format = Object.hasOwn(node, "format") ? Reflect.get(node, "format") : undefined;
+    return typeof format === "string" && URL_FORMATS.has(format);
+};
+const indexes = new WeakMap();
+const indexOf = (root) => {
+    let index = indexes.get(root);
+    if (!index) {
+        index = { root, reach: new Map(), applicable: new Map() };
+        indexes.set(root, index);
+    }
+    return index;
+};
+// Whether a URL format sits at or below `start`, through any keyword and any `$ref` chain. A stack, so depth sets no limit.
+const reachesUrlFormat = (index, start) => {
+    if (typeof start !== "object" || start === null)
+        return false;
+    const cached = index.reach.get(start);
+    if (cached !== undefined)
+        return cached;
+    const seen = new Set();
+    const stack = [start];
+    let found = false;
+    while (!found && stack.length > 0) {
+        const node = stack.pop();
+        if (typeof node !== "object" || node === null || seen.has(node))
+            continue;
+        seen.add(node);
+        found = hasUrlFormat(node);
+        for (const [key, child] of Object.entries(node)) {
+            stack.push(key === "$ref" && typeof child === "string" ? resolvePointer(child, index.root) : child);
+        }
+    }
+    index.reach.set(start, found);
+    return found;
+};
+// The nodes that hold for one value: `start` and every applicator under it that keeps the value.
+// All but `not` (a URL format under it forbids a URL); one that holds for only some values counts for all.
+const applicableNodes = (index, start) => {
+    const cached = index.applicable.get(start);
+    if (cached)
+        return cached;
+    const out = new Set();
+    const stack = [start];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (!isSchemaObject(node) || out.has(node) || !reachesUrlFormat(index, node))
+            continue;
+        out.add(node);
+        if (typeof node.$ref === "string")
+            stack.push(resolvePointer(node.$ref, index.root));
+        stack.push(...(node.allOf ?? []), ...(node.anyOf ?? []), ...(node.oneOf ?? []));
+        stack.push(node.if, node.then, node.else, ...Object.values(node.dependentSchemas ?? {}));
+    }
+    const nodes = [...out];
+    index.applicable.set(start, nodes);
+    return nodes;
+};
+const pathOf = (visit) => {
+    let path = "";
+    for (let at = visit; at?.parent; at = at.parent) {
+        const step = typeof at.key === "number" ? `[${at.key}]` : `.${at.key}`;
+        path = step + path;
+    }
+    return path.startsWith(".") ? path.slice(1) : path;
+};
+// A subschema with no URL format below it is never walked, so a URL-free table costs nothing.
+const pushVisit = (stack, index, node, value, parent, key) => {
+    if (isSchemaObject(node) && reachesUrlFormat(index, node))
+        stack.push({ node, value, parent, key });
+};
+// Only declared URL props are checked: a URL-looking `text` prop is content.
+export const findUrlViolations = (schema, value, policy) => {
+    if (!schema)
+        return [];
+    const index = indexOf(schema);
+    if (!reachesUrlFormat(index, schema))
+        return [];
+    const out = [];
+    const flagged = new Set();
+    // Per object, the nodes already applied: a shared or cyclic value is walked once per node.
+    const walked = new WeakMap();
+    // Children are pushed last to first, so values are checked, and violations reported, in document order.
+    const stack = [{ node: schema, value, parent: null, key: "" }];
+    for (let visit = stack.pop(); visit; visit = stack.pop()) {
+        const val = visit.value;
+        const nodes = applicableNodes(index, visit.node);
+        if (typeof val === "string") {
+            if (!nodes.some(hasUrlFormat))
+                continue;
+            const result = checkUrl(val, policy);
+            if (result.ok)
+                continue;
+            const path = pathOf(visit);
+            if (!flagged.has(path)) {
+                flagged.add(path);
+                out.push({ path, url: val, reason: result.reason });
+            }
+            continue;
+        }
+        if (typeof val !== "object" || val === null)
+            continue;
+        let done = walked.get(val);
+        if (!done) {
+            done = new Set();
+            walked.set(val, done);
+        }
+        for (let n = nodes.length - 1; n >= 0; n--) {
+            const node = nodes[n];
+            if (done.has(node))
+                continue;
+            done.add(node);
+            if (Array.isArray(val)) {
+                const tuple = node.prefixItems ?? [];
+                for (let i = val.length - 1; i >= 0; i--) {
+                    pushVisit(stack, index, node.unevaluatedItems, val[i], visit, i);
+                    pushVisit(stack, index, node.contains, val[i], visit, i);
+                    pushVisit(stack, index, i < tuple.length ? tuple[i] : node.items, val[i], visit, i);
+                }
+                continue;
+            }
+            const declared = node.properties ?? {};
+            // Patterns are not matched: each one applies to every key.
+            const patterns = Object.values(node.patternProperties ?? {});
+            const entries = Object.entries(val);
+            for (let e = entries.length - 1; e >= 0; e--) {
+                const [key, child] = entries[e];
+                if (Object.hasOwn(declared, key)) {
+                    pushVisit(stack, index, declared[key], child, visit, key);
+                }
+                else {
+                    pushVisit(stack, index, node.unevaluatedProperties, child, visit, key);
+                    pushVisit(stack, index, node.additionalProperties, child, visit, key);
+                }
+                for (const sub of patterns)
+                    pushVisit(stack, index, sub, child, visit, key);
+                pushVisit(stack, index, node.propertyNames, key, visit, key);
+            }
+        }
+    }
+    return out;
+};
+export const schemaHasUrlFormat = (schema) => schema !== undefined && reachesUrlFormat(indexOf(schema), schema);

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@uicast/core",
-  "version": "0.0.1-beta.1",
-  "description": "LLM-generated UIs from a stream of JSONLines — the framework-agnostic uicast engine: entry format, sandboxed expressions, reactive scopes, and prompt builders.",
+  "version": "0.0.1",
+  "description": "The framework-agnostic engine of uicast, the expression-driven generative UI framework: entry format, guarded expressions (allow-list, not a sandbox), reactive scopes, and prompt builders.",
   "license": "MIT",
+  "author": "Andrey Gubanov (https://github.com/finom)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/finom/uicast.git",
     "directory": "packages/core"
   },
-  "homepage": "https://github.com/finom/uicast#readme",
+  "homepage": "https://uicast.dev",
   "keywords": [
     "generative-ui",
     "llm",
-    "jsonlines",
     "streaming",
     "ui",
     "agent",
@@ -20,33 +20,42 @@
   ],
   "type": "module",
   "exports": {
-    ".": "./src/index.ts",
-    "./prompt": "./src/prompt/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
+    },
+    "./prompt": {
+      "types": "./dist/prompt/index.d.ts",
+      "default": "./dist/prompt/index.js"
+    }
   },
   "files": [
-    "src",
-    "!src/**/test/**",
+    "dist",
     "LICENSE",
     "CHANGELOG.md"
   ],
   "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "prepublishOnly": "node -e \"if (!process.env.CI) throw new Error('Publish from CI: PACKAGE=<dir> npm run patch or minor tags a release, and the tag publishes it')\" && npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "npm-publish": "if [ -z \"$NPM_TAG\" ]; then echo 'Error: NPM_TAG is not set'; exit 1; fi; npm publish --tag=$NPM_TAG"
-  },
-  "dependencies": {
-    "@standard-schema/spec": "^1.1.0",
-    "acorn": "^8.16.0",
-    "standard-tool": "^0.0.6"
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.1.0",
-    "vitest": "^4.1.0",
-    "zod": "~4.3.6"
+    "@vitest/coverage-v8": "^5.0.2",
+    "standard-tool": "^0.1.0",
+    "vitest": "^5.0.1",
+    "zod": "~4.6.5"
   },
   "publishConfig": {
     "access": "public"
+  },
+  "peerDependencies": {
+    "@uicast/expr": "^0.0.1"
   }
 }

package/src/def/create-component-definition.ts

@@ -1,21 +0,0 @@
-import type { CombinedSpec, ComponentDefinition } from "../types";
-
-/**
- * Value-side constructor for a {@link ComponentDefinition} (the type lives in
- * `types.ts`). Infers the concrete `props` / `callbacks` specs at the call site
- * and returns the def unchanged — its purpose is the inference + a single typed
- * authoring shape; `createComponentImplementation` later reads those inferred
- * types off the returned def.
- */
-export const createComponentDefinition = <
-  TProps extends CombinedSpec,
-  TCallbacks extends Record<string, CombinedSpec> = Record<string, never>,
->({
-  name,
-  description,
-  props,
-  callbacks,
-  hidden,
-}: ComponentDefinition<TProps, TCallbacks>): ComponentDefinition<TProps, TCallbacks> => {
-  return { name, description, props, callbacks, hidden };
-};

package/src/entry-error.ts

@@ -1,104 +0,0 @@
-// The engine's classified error: every failure surfaced to the host — through
-// the error slot or the Renderer's `onError` — is an EntryError. Classification
-// happens at the throw site (by provenance: whose code raised it), never by
-// inspecting messages. Reason names state the verdict, not the location.
-
-export type EntryErrorReason =
-  /** The expression doesn't parse. */
-  | "expression-syntax"
-  /** The expression uses syntax or reaches an API the sandbox blocks. */
-  | "sandbox-violation"
-  /** The expression references an identifier that doesn't exist — an unregistered function, a blocked-by-omission global, or an unknown scope path target. */
-  | "unknown-reference"
-  /** The element's `component` name has no implementation in the registry. */
-  | "unknown-component"
-  /** A list's `each` did not evaluate to an array, or a non-list element was rendered as a list. */
-  | "invalid-list"
-  /** The implementation's render threw, and the evaluated props FAIL the def's schema — the document sent a shape the contract forbids. */
-  | "invalid-props"
-  /** A host function rejected the arguments the document called it with (host functions throw this deliberately). */
-  | "invalid-arguments"
-  /** A host function threw or rejected while executing — server/host failure. */
-  | "host-function"
-  /** The host `init` callback threw or rejected. */
-  | "host-init"
-  /** The implementation's render threw on props its own def schema accepts — an implementation bug. */
-  | "implementation"
-  /** A valid expression threw at runtime (e.g. a property read through null) — the document wrote the path, but the host may have written the value. */
-  | "expression-runtime"
-  /** Escaped from an uninstrumented path — the defensive default. */
-  | "unknown";
-
-export type EntryFault = "document" | "environment" | "unknown";
-
-// The single source of truth `fault` derives from — every reason maps to
-// exactly one fault; hosts pick a side by picking the reason.
-const FAULT_BY_REASON: Record<EntryErrorReason, EntryFault> = {
-  "expression-syntax": "document",
-  "sandbox-violation": "document",
-  "unknown-reference": "document",
-  "unknown-component": "document",
-  "invalid-list": "document",
-  "invalid-props": "document",
-  "invalid-arguments": "document",
-  "host-function": "environment",
-  "host-init": "environment",
-  implementation: "environment",
-  "expression-runtime": "unknown",
-  unknown: "unknown",
-};
-
-export class EntryError extends Error {
-  readonly reason: EntryErrorReason;
-  /** The element the failure belongs to; the error boundary fills it in when the throw site couldn't. */
-  elementKey?: string;
-  // Brand marker: with git-dep consumption two copies of core can coexist in
-  // one bundle, where `instanceof` silently fails — `EntryError.is()` checks
-  // this instead.
-  readonly uicastEntryError = true;
-
-  constructor(
-    message: string,
-    options: { reason: EntryErrorReason; elementKey?: string; cause?: unknown },
-  ) {
-    super(
-      message,
-      options.cause !== undefined ? { cause: options.cause } : undefined,
-    );
-    this.name = "EntryError";
-    this.reason = options.reason;
-    this.elementKey = options.elementKey;
-  }
-
-  /** Coarse verdict for recovery flows: `document` → ask the model to re-emit; `environment` → the host's problem; `unknown` → undecidable. */
-  get fault(): EntryFault {
-    return FAULT_BY_REASON[this.reason];
-  }
-
-  /** Cross-copy-safe `instanceof`. */
-  static is(err: unknown): err is EntryError {
-    return (
-      typeof err === "object" &&
-      err !== null &&
-      (err as { uicastEntryError?: unknown }).uicastEntryError === true
-    );
-  }
-
-  /**
-   * Classify `err` as `reason`, keeping the original in `cause`. An error that
-   * is already an EntryError passes through untouched (the deepest — most
-   * precise — classification wins); a missing `elementKey` is filled in.
-   */
-  static wrap(
-    err: unknown,
-    reason: EntryErrorReason,
-    elementKey?: string,
-  ): EntryError {
-    if (EntryError.is(err)) {
-      if (elementKey && !err.elementKey) err.elementKey = elementKey;
-      return err;
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    return new EntryError(message, { reason, elementKey, cause: err });
-  }
-}

package/src/expr/analyze.ts

@@ -1,190 +0,0 @@
-import type * as acorn from "acorn";
-import { childNodes } from "./ast-utils";
-
-// Static analysis of a parsed expression (not the security check — that's
-// validate.ts). Two things the renderer needs: whether the expr is async
-// (containsAwait), and which scopes.X.Y paths it reads (extractScopeReads), so it
-// can subscribe without the LLM writing a deps array.
-
-/** Does the expression `await` anything? */
-export function containsAwait(node: acorn.AnyNode | null | undefined): boolean {
-  if (!node || typeof node !== "object") return false;
-  if (node.type === "AwaitExpression") return true;
-  for (const child of childNodes(node)) {
-    if (containsAwait(child)) return true;
-  }
-  return false;
-}
-
-// Collect every static scopes.X.Y chain the expression reads, stopping at the
-// first dynamic segment (computed key, call, non-identifier property). A method
-// call drops its last segment (rows.filter(...) depends on rows, not .filter).
-// The test file pins the trickier cases.
-
-// Read a member chain into its identifier segments (`a.b.c` -> ["a","b","c"]), or
-// null if it hits a computed / non-identifier segment.
-function collectChain(node: acorn.AnyNode | null | undefined): string[] | null {
-  const parts: string[] = [];
-  let cur: acorn.AnyNode | null | undefined = node;
-  while (cur) {
-    if (cur.type === "MemberExpression") {
-      if (cur.computed) return null;
-      const prop = cur.property;
-      if (prop.type !== "Identifier") return null;
-      parts.unshift(prop.name);
-      cur = cur.object;
-    } else if (cur.type === "Identifier") {
-      parts.unshift(cur.name);
-      return parts;
-    } else {
-      return null;
-    }
-  }
-  return null;
-}
-
-// A computed key can read scopes itself (`scopes.x[scopes.y]`), so walk the
-// computed parts of a chain too.
-function walkComputedKeysWithin(memberExpr: acorn.AnyNode, out: Set<string>): void {
-  let cur: acorn.AnyNode = memberExpr;
-  while (cur.type === "MemberExpression") {
-    if (cur.computed) {
-      walkScopeReads(cur.property, out);
-    }
-    cur = cur.object;
-  }
-}
-
-// The recursive walker behind extractScopeReads().
-function walkScopeReads(
-  node: acorn.AnyNode | null | undefined,
-  out: Set<string>,
-): void {
-  if (!node || typeof node !== "object") return;
-
-  // A method call depends on the chain, not the method name — record the chain
-  // without the method, then recurse args.
-  if (node.type === "CallExpression") {
-    const callee = node.callee;
-    if (callee.type === "MemberExpression" && !callee.computed) {
-      const chain = collectChain(callee.object);
-      if (chain && chain[0] === "scopes" && chain.length > 1) {
-        out.add(chain.join("."));
-        walkComputedKeysWithin(callee.object, out);
-      } else {
-        walkScopeReads(callee.object, out);
-      }
-    } else {
-      walkScopeReads(callee, out);
-    }
-    for (const arg of node.arguments) {
-      walkScopeReads(arg, out);
-    }
-    return;
-  }
-
-  // A plain member read: take the chain if it's rooted at `scopes`.
-  if (node.type === "MemberExpression") {
-    const chain = collectChain(node);
-    if (chain && chain[0] === "scopes" && chain.length > 1) {
-      out.add(chain.join("."));
-      walkComputedKeysWithin(node, out);
-      return;
-    }
-    // Not a scopes chain (or it hit a computed segment) — recurse for nested reads.
-    walkScopeReads(node.object, out);
-    if (node.computed) {
-      walkScopeReads(node.property, out);
-    }
-    return;
-  }
-
-  for (const child of childNodes(node)) {
-    walkScopeReads(child, out);
-  }
-}
-
-export function extractScopeReads(ast: acorn.AnyNode): string[] {
-  const out = new Set<string>();
-  walkScopeReads(ast, out);
-  return [...out];
-}
-
-// Free identifiers — names read from the outer scope (globals + injected
-// context). Anything bound by a param, destructuring, or a local declaration
-// stays internal and is not reported.
-function bindPattern(
-  node: acorn.AnyNode | null | undefined,
-  scope: Set<string>,
-): void {
-  if (!node) return;
-  if (node.type === "Identifier") {
-    scope.add(node.name);
-  } else if (node.type === "ObjectPattern") {
-    for (const p of node.properties)
-      bindPattern(p.type === "RestElement" ? p.argument : p.value, scope);
-  } else if (node.type === "ArrayPattern") {
-    for (const el of node.elements) if (el) bindPattern(el, scope);
-  } else if (node.type === "AssignmentPattern") {
-    bindPattern(node.left, scope);
-  } else if (node.type === "RestElement") {
-    bindPattern(node.argument, scope);
-  }
-}
-
-function isBound(name: string, stack: Set<string>[]): boolean {
-  for (let i = stack.length - 1; i >= 0; i--)
-    if (stack[i].has(name)) return true;
-  return false;
-}
-
-function walkFree(
-  node: acorn.AnyNode | null | undefined,
-  stack: Set<string>[],
-  out: Set<string>,
-): void {
-  if (!node || typeof node !== "object") return;
-
-  switch (node.type) {
-    case "Identifier":
-      if (!isBound(node.name, stack)) out.add(node.name);
-      return;
-    case "MemberExpression":
-      walkFree(node.object, stack, out);
-      if (node.computed) walkFree(node.property, stack, out);
-      return;
-    case "Property":
-      if (node.computed) walkFree(node.key, stack, out);
-      walkFree(node.value, stack, out);
-      return;
-    case "VariableDeclarator":
-      bindPattern(node.id, stack[stack.length - 1]);
-      walkFree(node.init, stack, out);
-      return;
-    case "ArrowFunctionExpression":
-    case "FunctionExpression": {
-      const scope = new Set<string>();
-      if (node.type === "FunctionExpression" && node.id)
-        scope.add(node.id.name);
-      for (const p of node.params) bindPattern(p, scope);
-      const inner = [...stack, scope];
-      for (const p of node.params) walkFree(p, inner, out);
-      walkFree(node.body, inner, out);
-      return;
-    }
-    case "CatchClause": {
-      const scope = new Set<string>();
-      if (node.param) bindPattern(node.param, scope);
-      walkFree(node.body, [...stack, scope], out);
-      return;
-    }
-  }
-
-  for (const child of childNodes(node)) walkFree(child, stack, out);
-}
-
-export function extractFreeIdentifiers(ast: acorn.AnyNode): string[] {
-  const out = new Set<string>();
-  walkFree(ast, [new Set()], out);
-  return [...out];
-}

package/src/expr/ast-utils.ts

@@ -1,28 +0,0 @@
-import type * as acorn from "acorn";
-
-// Low-level acorn-AST helpers shared by validate.ts and analyze.ts. NOT a parser
-// — acorn parses; these are a node type-guard and a child-traversal helper.
-
-/** Runtime guard: does `x` look like an AST node (object with a string `type`)? */
-export function isNode(x: unknown): x is acorn.AnyNode {
-  return (
-    typeof x === "object" &&
-    x !== null &&
-    typeof (x as { type?: unknown }).type === "string"
-  );
-}
-
-// Direct child nodes, flattening array-valued fields — for key-agnostic walks.
-export function childNodes(node: acorn.AnyNode): acorn.AnyNode[] {
-  const out: acorn.AnyNode[] = [];
-  for (const value of Object.values(
-    node as unknown as Record<string, unknown>,
-  )) {
-    if (Array.isArray(value)) {
-      for (const child of value) if (isNode(child)) out.push(child);
-    } else if (isNode(value)) {
-      out.push(value);
-    }
-  }
-  return out;
-}