@dforge-core/metadata 0.0.23 → 0.0.25

package/CHANGELOG.md

@@ -5,6 +5,99 @@ All notable changes to `@dforge-core/metadata` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this package adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.25] — 2026-09-15
+
+### Added
+
+- **`templateChunkValue()` and the `StringArg` type** are documented as exports of
+  `@dforge-core/metadata/dsl`. Both landed in 0.0.24 without an entry:
+  `CallRef.firstStringArg` became a `StringArg`, which reads a template literal as
+  well as a quoted string — reassembled from the chunks the lexer splits one into,
+  with `interpolated` marking the `${…}` holes and a space standing in for each —
+  so a rule that reads a call's first argument sees the multi-line form too.
+
+### Fixed
+
+- **`dsl/unknown-builtin` scopes a declared helper to its block, because the
+  compiler does.** `execute:` and `onBeforeStart:` are compiled to separate
+  scripts and each gets its own `CheckUndefinedReferences` pass, so a `function`
+  declared in one is undefined in the other — and the rule, which read
+  declarations across the whole file, accepted the call that install rejects. A
+  declaration above the first header belongs to no block and stays visible to
+  both; nothing legal can sit there.
+
+- **`dsl/job-record-context` stands down on a `records` the script binds
+  itself.** `var records = select(…)` is the very refactor the rule asks for, so
+  reporting it left the author with a diagnostic that its own fix could not
+  clear. Shadowing is read exactly as the execution-mode rule already reads it.
+
+## [0.0.24] — 2026-09-15
+
+### Added
+
+- **Module-local traits now expand.** `expandTrait` / `expandTraits` take an optional
+  third argument: a module's own root `traits.json` (new `TraitsFile` type). A module
+  may declare traits of its own, and an entity names them exactly like a platform trait
+  — so a reader that knows only this registry sees an entity missing columns that
+  install will give it. In the editor that surfaced as eight false "unknown column"
+  errors on `file-library/summarize.dsl`, whose `file_item` entity takes
+  `processing_status` / `processing_result` / `processing_error` from the module's own
+  `file-library` trait.
+
+  A code declared in both wins locally, mirroring the installer
+  (`TraitExpanderFactory.ForPackage` overlays the module's traits on the platform ones).
+  Expansion is now cycle-guarded: `includes` is author-supplied once local traits are in
+  play, and an unguarded walk is an editor hang rather than a bad expansion. The guard is
+  the current path rather than every trait already seen, so a trait two includes both
+  reach still expands under each — otherwise which definition won a key collision would
+  depend on which branch got there first.
+
+- **The DSL checker gained the rules that lived only in the module validator**
+  (`dforge-mcp`'s regex `dsl-check.ts`), ported onto the token stream:
+  `dsl/empty-script`, `dsl/missing-execute`, `dsl/duplicate-block`, `dsl/block-order`,
+  `dsl/formula-only-function` (`TODAY()` / `NOW()` / `CURRENT_USER_ID()` in a JavaScript
+  block), `dsl/sql-placeholder` (`:name` where the platform binds `@name`),
+  `dsl/sql-concat`, `dsl/unknown-builtin` and `dsl/job-record-context`. `DslContext.action`
+  gained `viaJob` for the last of these — a scheduled job runs as the system user with no
+  current record, which only a reader holding the module's jobs can know.
+
+  Being on the token stream rather than on regexes over blanked source, several are
+  sharper than the originals: `::text` is no longer read as a `:name` placeholder, a
+  statement built from a variable is skipped rather than guessed at, and a declared
+  helper — including the method shorthand `f(x) { … }` — is not an unknown built-in.
+
+  Each honours the disambiguation the older rules already carry. `dsl/sql-placeholder`
+  reads the statement with its string literals and comments blanked, so `':draft'` is
+  quoted data rather than a binding. `dsl/job-record-context` skips a local's array
+  literal and, in batch `execute:`, a keyword one — the same terms the column rule
+  uses. And the formula-only table is a `Map`, since its key is a name out of the
+  script and an object would answer `toString` from the prototype, reporting a
+  declared helper as formula-only and offering native source as the fix.
+  `stringValue()` now decodes `\n`, `\t` and `\r` rather than dropping the
+  backslash, so a multi-line SQL literal reads as the statement it is.
+
+  `dsl/block-order` follows `ParseBlocks` per block rather than as one sequence.
+  Each header regex has its own lookahead set, and only a block the one above it
+  omits is swallowed — `schema:` is listed by every other set, so it may sit
+  anywhere before `execute:`, which the earlier rank comparison rejected.
+  `dsl/job-record-context` covers all three forms `JobRegistrar.RequiresRecordContext`
+  rejects, not `[field]` alone: `old[field]` and `records` are record context too.
+  Both SQL rules read a template literal, which is how multi-line SQL is written
+  — a `${…}` hole counts as concatenation, and the chunks either side of it are
+  still scanned for `:name`. And `Set`, `Map`, `Promise`, `Symbol`, `BigInt` and
+  `encodeURI` / `decodeURI` joined the globals `dsl/unknown-builtin` stands down
+  on; Jint exposes them and `new Set()` was drawing a warning. A constructor is
+  skipped outright: `new Foo()` names no host function for the catalog to hold.
+
+### Changed
+
+- **`BLOCK_KINDS` is a `readonly` tuple**, not `BlockKind[]`. `BlockKind` now
+  derives from it, so the order check and the type it ranks cannot drift. The
+  narrowing is visible to callers: `BLOCK_KINDS.includes(s)` no longer accepts a
+  plain `string`, and the array can no longer be assigned to a mutable
+  `BlockKind[]`. Test the value first (`BLOCK_KINDS.some((k) => k === s)`) where
+  that bites.
+
 ## [0.0.23] — 2026-09-14
 
 ### Added

package/dist/dsl/index.d.ts

@@ -15,10 +15,22 @@ interface Token {
 declare function tokenize(text: string): Token[];
 /** Strip the surrounding quotes from a string token's text. */
 declare function stringValue(token: Token): string;
+/**
+ * The literal text of one template chunk, delimiters removed. A chunk opens on
+ * a backtick or on the `}` that closed the hole before it, and closes on a
+ * backtick, on the `${` of the next hole, or on the end of the file.
+ */
+declare function templateChunkValue(token: Token): string;
 
-type BlockKind = "params" | "canExecute" | "schema" | "onBeforeStart" | "execute";
-/** In the order `ActionDslCompiler.ParseBlocks` expects them in a file. */
-declare const BLOCK_KINDS: BlockKind[];
+/**
+ * In the order `ActionDslCompiler.ParseBlocks` expects them in a file.
+ *
+ * `BlockKind` derives from this array rather than standing beside it, so the
+ * two cannot drift: the order check ranks a kind by its index here, and a kind
+ * the array does not list could not have been produced in the first place.
+ */
+declare const BLOCK_KINDS: readonly ["params", "canExecute", "schema", "onBeforeStart", "execute"];
+type BlockKind = (typeof BLOCK_KINDS)[number];
 interface Span {
     start: number;
     end: number;
@@ -84,13 +96,21 @@ interface GlobalRef {
 interface CallRef {
     name: string;
     nameSpan: Span;
-    /** First argument when it is a string literal — the entity code, usually. */
-    firstStringArg?: {
-        value: string;
-        span: Span;
-    };
+    /** First argument when it is a string or template literal — the entity code, usually. */
+    firstStringArg?: StringArg;
     block: BlockKind | null;
 }
+interface StringArg {
+    value: string;
+    span: Span;
+    /**
+     * A template literal with `${…}` holes, which `value` holds a space in
+     * place of: literal text to read, but not a constant.
+     */
+    interpolated: boolean;
+    /** Index of the last token the literal consumes — its final chunk. */
+    endIndex: number;
+}
 interface DslDocument {
     blocks: DslBlock[];
     params: DslParam[];
@@ -200,6 +220,14 @@ interface DslContext {
     action?: {
         code: string;
         executionMode?: ActionExecutionMode;
+        /**
+         * True when a scheduled job invokes this action. A job runs as the
+         * system user with no current record, so record context is a hard
+         * error there even in a mode that would otherwise allow it. Only a
+         * reader that has the module's jobs can know this, so it is the host's
+         * to supply; absent, the rule stands down like every other.
+         */
+        viaJob?: boolean;
     };
     /**
      * Entity behind the record context (`[field]`). `null` or absent when it
@@ -220,4 +248,4 @@ interface DslContext {
  */
 declare function checkDsl(text: string, ctx?: DslContext): DslIssue[];
 
-export { BLOCK_KINDS, BUILTINS, BUILTIN_BY_NAME, BUILTIN_VALUES, type BlockKind, type Builtin, type CallRef, type ColumnLookup, type DslBlock, type DslContext, type DslDocument, type DslIssue, type DslParam, type DslSeverity, type EntityShape, type FieldRef, type GlobalRef, type Span, type Token, type TokenKind, checkDsl, parseDsl, stringValue, tokenize };
+export { BLOCK_KINDS, BUILTINS, BUILTIN_BY_NAME, BUILTIN_VALUES, type BlockKind, type Builtin, type CallRef, type ColumnLookup, type DslBlock, type DslContext, type DslDocument, type DslIssue, type DslParam, type DslSeverity, type EntityShape, type FieldRef, type GlobalRef, type Span, type StringArg, type Token, type TokenKind, checkDsl, parseDsl, stringValue, templateChunkValue, tokenize };

package/dist/dsl/index.js

@@ -269,7 +269,28 @@ function scanRegex(text, start) {
 function stringValue(token) {
   if (token.kind !== "string") return token.text;
   const body = token.text.slice(1, token.text.endsWith(token.text[0]) && token.text.length > 1 ? -1 : void 0);
-  return body.replace(/\\(.)/g, "$1");
+  return unescape(body);
+}
+function templateChunkValue(token) {
+  if (token.kind !== "template") return token.text;
+  const body = token.text.slice(1);
+  if (body.endsWith("${")) return unescape(body.slice(0, -2));
+  if (body.endsWith("`")) return unescape(body.slice(0, -1));
+  return unescape(body);
+}
+function unescape(body) {
+  return body.replace(/\\(.)/g, (_, ch) => {
+    switch (ch) {
+      case "n":
+        return "\n";
+      case "t":
+        return "	";
+      case "r":
+        return "\r";
+      default:
+        return ch;
+    }
+  });
 }
 
 // src/dsl/parse.ts
@@ -380,8 +401,12 @@ function parseDsl(text) {
       if (firstArg?.kind === "string") {
         call.firstStringArg = {
           value: stringValue(firstArg),
-          span: { start: firstArg.start, end: firstArg.end }
+          span: { start: firstArg.start, end: firstArg.end },
+          interpolated: false,
+          endIndex: i + 2
         };
+      } else if (firstArg?.kind === "template" && firstArg.text.startsWith("`")) {
+        call.firstStringArg = templateArg(tokens, i + 2);
       }
       calls.push(call);
     }
@@ -401,6 +426,37 @@ function parseDsl(text) {
 function isFieldAccessStart(text, start) {
   return start === 0 || !/\w/.test(text[start - 1]);
 }
+function templateArg(tokens, start) {
+  const parts = [];
+  let depth = 0;
+  let interpolated = false;
+  let last = tokens[start];
+  let endIndex = start;
+  for (let j = start; j < tokens.length; j++) {
+    const t = tokens[j];
+    if (t.kind !== "template") continue;
+    const opens = t.text.startsWith("`");
+    if (opens) depth++;
+    if (depth === 1) {
+      if (!opens) parts.push(" ");
+      parts.push(templateChunkValue(t));
+      last = t;
+      endIndex = j;
+    }
+    if (t.text.endsWith("${")) {
+      if (depth === 1) interpolated = true;
+      continue;
+    }
+    depth--;
+    if (depth === 0) break;
+  }
+  return {
+    value: parts.join(""),
+    span: { start: tokens[start].start, end: last.end },
+    interpolated,
+    endIndex
+  };
+}
 function indexedRecordField(tokens, i) {
   const index = tokens[i + 2];
   if (tokens[i + 1]?.text !== "[") return null;
@@ -574,17 +630,18 @@ function blockLabelAt(tokens, i) {
   if (!t || t.kind !== "ident" || !t.startsLine) return null;
   const colon = tokens[i + 1];
   if (colon?.text !== ":" || colon.start !== t.end) return null;
-  return BLOCK_BY_LOWER.get(t.text.toLowerCase()) ?? null;
+  const kind = BLOCK_BY_LOWER.get(t.text.toLowerCase());
+  return kind ? { kind, span: { start: t.start, end: colon.end } } : null;
 }
 function findBlocks(text, tokens) {
   const labels = [];
   for (let i = 0; i < tokens.length; i++) {
     const t = tokens[i];
     if (t.character !== 0) continue;
-    const kind = blockLabelAt(tokens, i);
-    if (!kind) continue;
-    labels.push({ kind, span: { start: t.start, end: tokens[i + 1].end } });
-    if (kind === "execute") break;
+    const label = blockLabelAt(tokens, i);
+    if (!label) continue;
+    labels.push(label);
+    if (label.kind === "execute") break;
   }
   return labels.map((l, idx) => ({
     kind: l.kind,
@@ -854,6 +911,64 @@ function checkDsl(text, ctx = {}) {
   const entity = ctx.currentEntity ?? null;
   const isBatch = (action?.executionMode ?? "single") === "batch";
   const hasColumn = columnMatcher(entity?.columns);
+  if (text.trim() === "") {
+    add(
+      { start: 0, end: text.length },
+      "A DSL body needs at least an execute: block \u2014 an empty file installs an action that does nothing.",
+      "error",
+      "dsl/empty-script"
+    );
+    return out;
+  }
+  const firstToken = parsed.tokens[0];
+  const firstLabel = parsed.blocks[0]?.label ?? (firstToken ? { start: firstToken.start, end: firstToken.end } : { start: 0, end: text.length });
+  if (!parsed.blocks.some((b) => b.kind === "execute")) {
+    add(
+      firstLabel,
+      "No execute: block \u2014 it is the only required block, and the compiler runs nothing without it.",
+      "error",
+      "dsl/missing-execute"
+    );
+  }
+  const executeBlock = parsed.blocks.find((b) => b.kind === "execute");
+  if (executeBlock) {
+    for (let i = 0; i < parsed.tokens.length; i++) {
+      const token = parsed.tokens[i];
+      if (token.start <= executeBlock.label.start) continue;
+      if (token.character !== 0) continue;
+      const label = blockLabelAt(parsed.tokens, i);
+      if (!label) continue;
+      add(
+        label.span,
+        label.kind === "execute" ? `"execute:" is declared more than once \u2014 the first one's body runs to the end of the file, so this header and everything under it are swallowed into it and parsed as JavaScript. Merge the two into one execute: block.` : `"${label.kind}:" is below execute:, whose body runs to the end of the file \u2014 the header and everything under it are swallowed into the execute: script and parsed as JavaScript. Move it above execute:.`,
+        "error",
+        "dsl/block-after-execute"
+      );
+    }
+  }
+  const seenBlocks = /* @__PURE__ */ new Set();
+  for (let i = 0; i < parsed.blocks.length; i++) {
+    const block = parsed.blocks[i];
+    if (seenBlocks.has(block.kind)) {
+      add(
+        block.label,
+        `"${block.kind}:" is declared more than once \u2014 the compiler keeps one and silently drops the other.`,
+        "error",
+        "dsl/duplicate-block"
+      );
+      continue;
+    }
+    seenBlocks.add(block.kind);
+    const prev = parsed.blocks[i - 1];
+    if (prev && prev.kind !== "execute" && !BLOCK_STOPS[prev.kind].has(block.kind)) {
+      add(
+        block.label,
+        `"${block.kind}:" must come before "${prev.kind}:" \u2014 the compiler reads ${prev.kind}: up to the next header it recognises, and ${block.kind}: is not one of them, so this header and its body end up inside the ${prev.kind}: body.`,
+        "error",
+        "dsl/block-order"
+      );
+    }
+  }
   for (const ref of parsed.fieldRefs) {
     if (ref.block === "schema" || ref.block === "params") continue;
     const isDslBlock = ref.block === "execute" || ref.block === "onBeforeStart";
@@ -945,7 +1060,7 @@ function checkDsl(text, ctx = {}) {
     if (call.name === "userId") {
       add(
         call.nameSpan,
-        "userId is a bare identifier \u2014 userId() is a compile error.",
+        "'userId' is a value, not a function \u2014 write userId without parentheses, or currentUserId(). The compiler's bare-identifier rewrite fires either way, so userId() reaches Jint as a call against a number.",
         "error",
         "dsl/user-id-call"
       );
@@ -955,6 +1070,7 @@ function checkDsl(text, ctx = {}) {
     if (!builtin || builtin.entityArg === void 0) continue;
     const arg = call.firstStringArg;
     if (!arg) continue;
+    if (arg.interpolated) continue;
     if (arg.value.includes(".") || ctx.moduleCode?.includes("-")) continue;
     add(
       arg.span,
@@ -981,14 +1097,14 @@ function checkDsl(text, ctx = {}) {
       depth = Math.max(0, depth - 1);
     }
     if (depth === 0 && token.character > 0) {
-      const kind = blockLabelAt(parsed.tokens, i);
+      const label = blockLabelAt(parsed.tokens, i);
       const isParamDecl = parsed.params.some(
         (p) => p.nameSpan.start === token.start
       );
-      if (kind && !isParamDecl) {
+      if (label && !isParamDecl) {
         add(
-          { start: token.start, end: parsed.tokens[i + 1].end },
-          `Block headers start at column 0. Indented, "${kind}:" is body text \u2014 the compiler never opens the block, and it runs as if empty.`,
+          label.span,
+          `Block headers start at column 0. Indented, "${label.kind}:" is body text \u2014 the compiler never opens the block, and it runs as if empty.`,
           "error",
           "dsl/indented-block-header"
         );
@@ -1008,6 +1124,111 @@ function checkDsl(text, ctx = {}) {
       "dsl/top-level-return"
     );
   }
+  for (const call of parsed.calls) {
+    const replacement = FORMULA_ONLY.get(call.name);
+    if (!replacement) continue;
+    if (call.block !== "execute" && call.block !== "onBeforeStart") continue;
+    add(
+      call.nameSpan,
+      `${call.name}() is formula-only \u2014 in ${call.block}: it is undefined and install fails with "'${call.name}' is not defined". Write ${replacement}.`,
+      "error",
+      "dsl/formula-only-function"
+    );
+  }
+  const tokenAt = new Map(parsed.tokens.map((t, i) => [t.start, i]));
+  for (const call of parsed.calls) {
+    if (call.name !== "query" && call.name !== "callProc") continue;
+    const arg = call.firstStringArg;
+    if (!arg) continue;
+    const bad = /(^|[^:\w]):([a-z][a-z0-9_]*)/i.exec(stripSqlNoise(arg.value));
+    if (bad) {
+      const name = bad[2];
+      add(
+        arg.span,
+        `SQL binds @name, not :name \u2014 rewrite ':${name}' as '@${name}' and pass { ${name}: value } as the params argument.`,
+        "error",
+        "dsl/sql-placeholder"
+      );
+    }
+    if (arg.interpolated || parsed.tokens[arg.endIndex + 1]?.text === "+") {
+      const built = arg.interpolated ? "${\u2026} interpolation" : "concatenation";
+      add(
+        arg.span,
+        // callProc's first argument is the procedure name, and an
+        // identifier cannot be bound — the @placeholder advice cannot
+        // be followed there.
+        call.name === "callProc" ? `Procedure name built by ${built} \u2014 a name is an identifier, so it cannot be bound as a @placeholder. Choose between fixed names in the script rather than splicing a value into one.` : `SQL built by ${built} \u2014 pass @placeholders and a params object instead, so values are bound rather than spliced into the statement.`,
+        "warning",
+        "dsl/sql-concat"
+      );
+    }
+  }
+  const declaredFunctions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < parsed.tokens.length; i++) {
+    const token = parsed.tokens[i];
+    if (token.text !== "function") continue;
+    const name = parsed.tokens[i + 1];
+    if (name?.kind !== "ident") continue;
+    const blocks = declaredFunctions.get(name.text) ?? /* @__PURE__ */ new Set();
+    blocks.add(blockOf(parsed, token.start));
+    declaredFunctions.set(name.text, blocks);
+  }
+  const isDeclaredIn = (name, block) => {
+    const blocks = declaredFunctions.get(name);
+    return blocks !== void 0 && (blocks.has(null) || blocks.has(block));
+  };
+  const reportedUnknown = /* @__PURE__ */ new Set();
+  for (const call of parsed.calls) {
+    if (call.block !== "execute" && call.block !== "onBeforeStart") continue;
+    const name = call.name;
+    const idx = tokenAt.get(call.nameSpan.start);
+    if (idx !== void 0) {
+      const prev = parsed.tokens[idx - 1]?.text;
+      if (prev === "function" || prev === "new") continue;
+      if (isMethodName(parsed.tokens, idx)) continue;
+    }
+    if (BUILTIN_BY_NAME.has(name) || CONTROL_KEYWORDS.has(name) || KEYWORDS_BEFORE_PAREN.has(name) || JS_GLOBALS.has(name) || FORMULA_ONLY.has(name) || // Its own rule reports this one, with better wording.
+    name === "userId" || isDeclaredIn(name, call.block) || parsed.locals.has(name) || reportedUnknown.has(name)) {
+      continue;
+    }
+    reportedUnknown.add(name);
+    add(
+      call.nameSpan,
+      `"${name}()" is not a DSL host function, and nothing in this script declares it. Check it against the built-in catalog.`,
+      "warning",
+      "dsl/unknown-builtin"
+    );
+  }
+  if (ctx.action?.viaJob) {
+    const inScript = (block) => block === "execute" || block === "onBeforeStart";
+    const bound = [];
+    for (const ref of parsed.fieldRefs) {
+      if (!inScript(ref.block)) continue;
+      if (isBatch && ref.block === "execute" && LITERAL_NAMES.has(ref.name))
+        continue;
+      if (ref.isCurrentRecord && parsed.locals.has(ref.name)) continue;
+      bound.push({ span: ref.outerSpan, read: `[${ref.name}]` });
+    }
+    for (const ref of parsed.globalRefs) {
+      if (ref.global !== "old" || !inScript(ref.block)) continue;
+      bound.push({ span: ref.span, read: `old[${ref.property}]` });
+    }
+    if (!parsed.locals.has("records")) {
+      for (const span of parsed.recordsRefs) {
+        if (!inScript(blockOf(parsed, span.start))) continue;
+        bound.push({ span, read: "records" });
+      }
+    }
+    const first = bound.sort((a, b) => a.span.start - b.span.start)[0];
+    if (first) {
+      add(
+        first.span,
+        `Action "${ctx.action.code}" is invoked by a scheduled job, which runs as the system user with no record bound \u2014 ${first.read} has nothing to read. Fetch rows with select() or query() instead.`,
+        "error",
+        "dsl/job-record-context"
+      );
+    }
+  }
   out.push(...inlineAssignmentIssues(parsed, positionAt));
   return out;
 }
@@ -1039,6 +1260,62 @@ function opensFunctionBody(tokens, i, matchingParenOpen) {
   const head = tokens[matchingParenOpen - 1];
   return head?.kind === "ident" && !CONTROL_KEYWORDS.has(head.text);
 }
+var BLOCK_STOPS = {
+  params: /* @__PURE__ */ new Set(["schema", "canExecute", "onBeforeStart", "execute"]),
+  canExecute: /* @__PURE__ */ new Set(["schema", "onBeforeStart", "execute"]),
+  schema: /* @__PURE__ */ new Set(["params", "canExecute", "onBeforeStart", "execute"]),
+  onBeforeStart: /* @__PURE__ */ new Set(["schema", "execute"]),
+  execute: /* @__PURE__ */ new Set()
+};
+var FORMULA_ONLY = /* @__PURE__ */ new Map([
+  ["TODAY", "now()"],
+  ["NOW", "now()"],
+  ["CURRENT_USER_ID", "currentUserId()"]
+]);
+var KEYWORDS_BEFORE_PAREN = /* @__PURE__ */ new Set([
+  "function",
+  "return",
+  "typeof",
+  "instanceof",
+  "new",
+  "delete",
+  "void",
+  "in",
+  "of",
+  "do",
+  "else",
+  "try",
+  "throw",
+  "yield",
+  "await"
+]);
+var JS_GLOBALS = /* @__PURE__ */ new Set([
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "encodeURI",
+  "decodeURI",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "String",
+  "Number",
+  "Boolean",
+  "Array",
+  "Object",
+  "Date",
+  "Math",
+  "JSON",
+  "RegExp",
+  "Error",
+  "Set",
+  "Map",
+  "WeakSet",
+  "WeakMap",
+  "Promise",
+  "Symbol",
+  "BigInt"
+]);
 var LITERAL_NAMES = /* @__PURE__ */ new Set([
   "true",
   "false",
@@ -1047,6 +1324,56 @@ var LITERAL_NAMES = /* @__PURE__ */ new Set([
   "FALSE",
   "NULL"
 ]);
+function stripSqlNoise(sql) {
+  let out = "";
+  let i = 0;
+  while (i < sql.length) {
+    const c = sql[i];
+    if (c === "'" || c === '"') {
+      const quote = c;
+      out += " ";
+      i++;
+      while (i < sql.length) {
+        if (sql[i] === quote && sql[i + 1] === quote) {
+          out += "  ";
+          i += 2;
+          continue;
+        }
+        if (sql[i] === quote) break;
+        out += sql[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+      if (i < sql.length) {
+        out += " ";
+        i++;
+      }
+      continue;
+    }
+    if (c === "-" && sql[i + 1] === "-") {
+      while (i < sql.length && sql[i] !== "\n") {
+        out += " ";
+        i++;
+      }
+      continue;
+    }
+    if (c === "/" && sql[i + 1] === "*") {
+      out += "  ";
+      i += 2;
+      while (i < sql.length && !(sql[i] === "*" && sql[i + 1] === "/")) {
+        out += sql[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+      if (i < sql.length) {
+        out += "  ";
+        i += 2;
+      }
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
 function blockOf(parsed, offset) {
   return parsed.blocks.find((b) => offset >= b.body.start && offset < b.body.end)?.kind ?? null;
 }
@@ -1103,6 +1430,7 @@ export {
   checkDsl,
   parseDsl,
   stringValue,
+  templateChunkValue,
   tokenize
 };
 //# sourceMappingURL=index.js.map