@flanksource/clicky-ui 0.3.21 → 0.3.23

package/dist/profiles/cel/celExpression.cjs

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const connectionBrowserModel = require("../connections/connectionBrowserModel.cjs");
+const profileApi = require("../profileApi.cjs");
+const CEL_EDITOR_WIDGET = "cel-editor";
+function evaluateCel(request) {
+  const configured = profileApi.celEvaluator();
+  if (configured) return configured(request);
+  return connectionBrowserModel.fetchJSON(profileApi.profileApiPath("profile/sample/expression"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request)
+  });
+}
+function coverage(results) {
+  const types = /* @__PURE__ */ new Set();
+  const barren = [];
+  let ok = 0;
+  let empty = 0;
+  let failed = 0;
+  for (const result of results) {
+    if (result.error) {
+      failed += 1;
+      barren.push(result.index);
+      continue;
+    }
+    if (result.value === null || result.value === void 0) {
+      empty += 1;
+      barren.push(result.index);
+      continue;
+    }
+    ok += 1;
+    if (result.type) types.add(result.type);
+  }
+  return { ok, empty, failed, barren, types: [...types].sort() };
+}
+function nextBarren(coverageResult, from) {
+  return coverageResult.barren.find((index) => index > from) ?? coverageResult.barren[0];
+}
+function isClean(coverageResult) {
+  return coverageResult.failed === 0 && coverageResult.empty === 0;
+}
+function isIdentifier(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+function bindingsFor(scope, row) {
+  if (scope === "batch") {
+    return [
+      { name: "batch", detail: "list · the grouped rows, oldest first" },
+      { name: "first", detail: "map · batch[0]" },
+      { name: "last", detail: "map · the final row of the batch" },
+      { name: "count", detail: "int · how many rows collapsed" },
+      { name: "row", detail: "map · the kept row" }
+    ];
+  }
+  if (scope === "boundary") {
+    return [
+      { name: "row", detail: "map · the row being judged" },
+      { name: "prev", detail: "map · the row above it" },
+      { name: "index", detail: "int · position in the result" }
+    ];
+  }
+  const fixed = [
+    { name: "row", detail: "map · the whole row" },
+    { name: "span", detail: "map · the same row, for trace profiles" }
+  ];
+  if (!row) return fixed;
+  const flattened = Object.keys(row).filter(isIdentifier).filter((key) => key !== "row" && key !== "span").sort().map((key) => ({ name: key, detail: `bound bare and as row.${key}`, value: row[key] }));
+  return [...fixed, ...flattened];
+}
+function unreachableKeys(row) {
+  return Object.keys(row ?? {}).filter((key) => !isIdentifier(key));
+}
+const RAW_ERROR_LIMIT = 240;
+function elide(text, limit = RAW_ERROR_LIMIT) {
+  if (text.length <= limit) return text;
+  const head = Math.ceil((limit - 1) / 2);
+  return `${text.slice(0, head)}…${text.slice(text.length - (limit - 1 - head))}`;
+}
+const ARRAY_INTO_OBJECT = /cannot unmarshal\s+!!seq\s+into\s+map\[string\]interface\s*\{\s*\}/;
+const OBJECT_INTO_ARRAY = /cannot unmarshal\s+!!map\s+into\s+\[\]interface\s*\{\s*\}/;
+function explainCelError(error, draft) {
+  const raw = elide(error);
+  if (ARRAY_INTO_OBJECT.test(error)) {
+    const failure = {
+      message: "That value is a JSON array. JSON() decodes an object — use JSONArray(), then index or filter it.",
+      raw
+    };
+    if (draft.includes(".JSON()")) failure.fix = draft.replaceAll(".JSON()", ".JSONArray()");
+    return failure;
+  }
+  if (OBJECT_INTO_ARRAY.test(error)) {
+    const failure = {
+      message: "That value is a JSON object. JSONArray() decodes a list — use JSON().",
+      raw
+    };
+    if (draft.includes(".JSONArray()")) failure.fix = draft.replaceAll(".JSONArray()", ".JSON()");
+    return failure;
+  }
+  return { message: raw, raw };
+}
+function isKeyValueList(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(
+    (entry) => entry !== null && typeof entry === "object" && "key" in entry && "value" in entry
+  );
+}
+function decoded(value) {
+  if (typeof value !== "string") return value;
+  const text = value.trim();
+  if (!text.startsWith("{") && !text.startsWith("[")) return value;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return value;
+  }
+}
+function celExamplesFor(accessor, value) {
+  var _a;
+  const inner = decoded(value);
+  const range = `dyn(${accessor})`;
+  if (isKeyValueList(inner)) {
+    const sample = String(((_a = inner[0]) == null ? void 0 : _a["key"]) ?? "key");
+    const asMap = `${range}.fold(e, acc, merge(acc, {e.key: e.value}))`;
+    return [
+      { label: `Read ${sample}`, expression: `${asMap}[${JSON.stringify(sample)}]` },
+      // The map itself has to be encoded to leave the engine: a CEL map is a
+      // map[ref.Val]ref.Val, which the response cannot serialize. Indexing one
+      // yields a scalar and needs no such call, which is why only this example
+      // carries it.
+      { label: "Fold every entry into a map", expression: `${asMap}.toJSON()` },
+      { label: "List the keys", expression: `${range}.map(e, e.key)` },
+      { label: "Keep the whole list", expression: accessor }
+    ];
+  }
+  if (Array.isArray(inner)) {
+    const field = Object.keys(inner[0] ?? {})[0];
+    return [
+      { label: "Take the first entry", expression: `${accessor}[0]` },
+      { label: "Count the entries", expression: `size(${accessor})` },
+      ...field ? [{ label: `Pull ${field} from each`, expression: `${range}.map(e, e.${field})` }] : [],
+      { label: "Keep the whole list", expression: accessor }
+    ];
+  }
+  if (inner !== null && typeof inner === "object") {
+    const field = Object.keys(inner)[0];
+    return [
+      ...field ? [
+        { label: `Read ${field}`, expression: `${accessor}.${field}` },
+        {
+          label: `Default ${field} when missing`,
+          expression: `has(${accessor}.${field}) ? ${accessor}.${field} : ""`
+        }
+      ] : [],
+      { label: "List the keys", expression: `${accessor}.keys()` },
+      { label: "Keep the whole object", expression: accessor }
+    ];
+  }
+  return [
+    { label: "Read it", expression: accessor },
+    { label: "Convert to text", expression: `string(${accessor})` },
+    ...typeof inner === "number" ? [{ label: "Scale by 1,000", expression: `${accessor} / 1000.0` }] : []
+  ];
+}
+exports.CEL_EDITOR_WIDGET = CEL_EDITOR_WIDGET;
+exports.bindingsFor = bindingsFor;
+exports.celExamplesFor = celExamplesFor;
+exports.coverage = coverage;
+exports.evaluateCel = evaluateCel;
+exports.explainCelError = explainCelError;
+exports.isClean = isClean;
+exports.isIdentifier = isIdentifier;
+exports.nextBarren = nextBarren;
+exports.unreachableKeys = unreachableKeys;
+//# sourceMappingURL=celExpression.cjs.map

package/dist/profiles/cel/celExpression.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"celExpression.cjs","sources":["../../../src/profiles/cel/celExpression.ts"],"sourcesContent":["import { fetchJSON } from \"../connections/connectionBrowserModel\";\nimport { celEvaluator, profileApiPath } from \"../profileApi\";\n\n/**\n * The three binding environments a profile's CEL can compile against.\n *\n * The schema tags each CEL field with the one it belongs to\n * (`x-clicky-cel-scope`), because the document itself does not record it: a\n * column's expression and a processor's `set` are two strings in the same YAML\n * that see different variables.\n */\nexport type CelScope = \"row\" | \"batch\" | \"boundary\";\n\n/**\n * The `x-clicky-component` hint the profile schema tags every CEL field with, so\n * the form offers an editor that knows the bindings and can evaluate rather than\n * a bare input. Mirrors query/schema.celEditorComponent.\n */\nexport const CEL_EDITOR_WIDGET = \"cel-editor\";\n\nexport type CelResult = {\n  index: number;\n  value?: unknown;\n  type?: string;\n  error?: string;\n};\n\nexport type CelResponse = {\n  results: CelResult[];\n  error?: string;\n};\n\nexport type CelRequest = {\n  cel: string;\n  scope: CelScope;\n  rows: unknown[];\n  keep?: string;\n};\n\n/** What runs an expression for the editor. See {@link evaluateCel}. */\nexport type CelEvaluator = (request: CelRequest) => Promise<CelResponse>;\n\n/**\n * Evaluates an expression against the sampled rows, once per row.\n *\n * It has to be run by the engine that will run it for real, or the preview would\n * confidently disagree with the column it previews — CEL here is null-safe in\n * ways a browser reimplementation would not reproduce. The rows travel up with\n * the request because the caller already sampled them.\n *\n * Which engine that is belongs to the host: the default posts to commons-db's\n * profile service at the configured mount, and a host whose expressions are\n * evaluated somewhere else — a different route, an RPC, a WASM build running in\n * the tab — supplies its own through `configureProfiles({ celEvaluator })`\n * rather than forking the editor.\n */\nexport function evaluateCel(request: CelRequest): Promise<CelResponse> {\n  const configured = celEvaluator();\n  if (configured) return configured(request);\n  return fetchJSON<CelResponse>(profileApiPath(\"profile/sample/expression\"), {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify(request),\n  });\n}\n\nexport type CelCoverage = {\n  /** Rows that produced a usable value. */\n  ok: number;\n  /** Rows the expression read nothing from. */\n  empty: number;\n  /** Rows where evaluation itself failed. */\n  failed: number;\n  /** Indices of rows that produced nothing usable, in row order. */\n  barren: number[];\n  /** The distinct result types seen, so a column that is sometimes a string shows. */\n  types: string[];\n};\n\n/**\n * What an expression did across the whole sample.\n *\n * `empty` is deliberately not folded into `ok`. An out-of-range index or a\n * missing field does not throw in this engine — it reads as null — so the\n * expression that is wrong about most of the data still returns cleanly, and\n * counting those rows as successes is exactly the mistake this view exists to\n * prevent.\n */\nexport function coverage(results: CelResult[]): CelCoverage {\n  const types = new Set<string>();\n  const barren: number[] = [];\n  let ok = 0;\n  let empty = 0;\n  let failed = 0;\n\n  for (const result of results) {\n    if (result.error) {\n      failed += 1;\n      barren.push(result.index);\n      continue;\n    }\n    if (result.value === null || result.value === undefined) {\n      empty += 1;\n      barren.push(result.index);\n      continue;\n    }\n    ok += 1;\n    if (result.type) types.add(result.type);\n  }\n\n  return { ok, empty, failed, barren, types: [...types].sort() };\n}\n\n/**\n * The next row worth looking at after `from`, wrapping.\n *\n * An author works from the rows on screen and the rows an expression reads\n * nothing from are, by definition, ones they have not looked at — so the editor\n * has to be able to go and find them.\n */\nexport function nextBarren(coverageResult: CelCoverage, from: number): number | undefined {\n  return coverageResult.barren.find((index) => index > from) ?? coverageResult.barren[0];\n}\n\n/** True when the expression is safe to apply: every sampled row evaluated. */\nexport function isClean(coverageResult: CelCoverage): boolean {\n  return coverageResult.failed === 0 && coverageResult.empty === 0;\n}\n\n/** `^[A-Za-z_][A-Za-z0-9_]*$` — the rule the engine flattens a row key by. */\nexport function isIdentifier(key: string): boolean {\n  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);\n}\n\nexport type Binding = { name: string; detail: string; value?: unknown };\n\n/**\n * What an expression may name in `scope`.\n *\n * Only `row` and `span` are fixed in the row scope — every other name comes from\n * the data, because the engine binds each row key that is a valid identifier as\n * a bare variable. A key that is not one, like `@timestamp`, is reachable only\n * through `row`, and the palette says so by omission rather than offering a name\n * that will not compile.\n */\nexport function bindingsFor(scope: CelScope, row: Record<string, unknown> | undefined): Binding[] {\n  if (scope === \"batch\") {\n    return [\n      { name: \"batch\", detail: \"list · the grouped rows, oldest first\" },\n      { name: \"first\", detail: \"map · batch[0]\" },\n      { name: \"last\", detail: \"map · the final row of the batch\" },\n      { name: \"count\", detail: \"int · how many rows collapsed\" },\n      { name: \"row\", detail: \"map · the kept row\" },\n    ];\n  }\n  if (scope === \"boundary\") {\n    return [\n      { name: \"row\", detail: \"map · the row being judged\" },\n      { name: \"prev\", detail: \"map · the row above it\" },\n      { name: \"index\", detail: \"int · position in the result\" },\n    ];\n  }\n\n  const fixed: Binding[] = [\n    { name: \"row\", detail: \"map · the whole row\" },\n    { name: \"span\", detail: \"map · the same row, for trace profiles\" },\n  ];\n  if (!row) return fixed;\n\n  const flattened = Object.keys(row)\n    .filter(isIdentifier)\n    .filter((key) => key !== \"row\" && key !== \"span\")\n    .sort()\n    .map((key) => ({ name: key, detail: `bound bare and as row.${key}`, value: row[key] }));\n\n  return [...fixed, ...flattened];\n}\n\n/** Row keys that exist but cannot be named directly. */\nexport function unreachableKeys(row: Record<string, unknown> | undefined): string[] {\n  return Object.keys(row ?? {}).filter((key) => !isIdentifier(key));\n}\n\n/**\n * A failure the author can act on, read out of the engine's own words.\n *\n * The engine reports in the vocabulary of the Go library underneath it, so\n * decoding an array with `.JSON()` — a mistake the type system cannot catch,\n * because both decoders take a string — comes back as a YAML type name and the\n * entire offending value inline. Neither says what to do.\n */\nexport type CelFailure = {\n  /** What went wrong, in the author's terms. */\n  message: string;\n  /** The draft rewritten to fix it, when the fix is unambiguous. */\n  fix?: string;\n  /** The engine's own words, kept for a failure this cannot explain. */\n  raw: string;\n};\n\n/** How much of an error is worth showing before it buries the dialog. */\nconst RAW_ERROR_LIMIT = 240;\n\n/**\n * Shortens an error from the middle.\n *\n * Both ends carry the meaning — the prefix names the operation that failed and\n * the suffix names the failure — and it is the value interpolated between them\n * that runs to kilobytes. Trimming the tail would throw away the diagnosis and\n * keep the payload, which is the wrong half.\n */\nfunction elide(text: string, limit = RAW_ERROR_LIMIT): string {\n  if (text.length <= limit) return text;\n  const head = Math.ceil((limit - 1) / 2);\n  return `${text.slice(0, head)}…${text.slice(text.length - (limit - 1 - head))}`;\n}\n\n/**\n * `.JSON()` decodes an object; the value was an array. The signature is the Go\n * map type the decode targeted — matched on that rather than on the message\n * around it, which carries the whole value and so is never stable.\n */\nconst ARRAY_INTO_OBJECT = /cannot unmarshal\\s+!!seq\\s+into\\s+map\\[string\\]interface\\s*\\{\\s*\\}/;\n\n/** Conversely: `.JSONArray()` on an object. */\nconst OBJECT_INTO_ARRAY = /cannot unmarshal\\s+!!map\\s+into\\s+\\[\\]interface\\s*\\{\\s*\\}/;\n\nexport function explainCelError(error: string, draft: string): CelFailure {\n  const raw = elide(error);\n\n  if (ARRAY_INTO_OBJECT.test(error)) {\n    const failure: CelFailure = {\n      message:\n        \"That value is a JSON array. JSON() decodes an object — use JSONArray(), then index or filter it.\",\n      raw,\n    };\n    if (draft.includes(\".JSON()\")) failure.fix = draft.replaceAll(\".JSON()\", \".JSONArray()\");\n    return failure;\n  }\n\n  if (OBJECT_INTO_ARRAY.test(error)) {\n    const failure: CelFailure = {\n      message: \"That value is a JSON object. JSONArray() decodes a list — use JSON().\",\n      raw,\n    };\n    if (draft.includes(\".JSONArray()\")) failure.fix = draft.replaceAll(\".JSONArray()\", \".JSON()\");\n    return failure;\n  }\n\n  return { message: raw, raw };\n}\n\n/** An example expression the author can drop into the draft. */\nexport type CelExample = { label: string; expression: string };\n\n/** Whether a list looks like OpenTelemetry's `[{key, type, value}]` tag shape. */\nfunction isKeyValueList(value: unknown): value is Array<Record<string, unknown>> {\n  return (\n    Array.isArray(value) &&\n    value.length > 0 &&\n    value.every(\n      (entry) =>\n        entry !== null && typeof entry === \"object\" && \"key\" in entry && \"value\" in entry,\n    )\n  );\n}\n\n/** The value behind an accessor, decoded when the column holds JSON as text. */\nfunction decoded(value: unknown): unknown {\n  if (typeof value !== \"string\") return value;\n  const text = value.trim();\n  if (!text.startsWith(\"{\") && !text.startsWith(\"[\")) return value;\n  try {\n    return JSON.parse(text) as unknown;\n  } catch {\n    return value;\n  }\n}\n\n/**\n * Examples that fit the value in front of the author.\n *\n * A fixed list is wrong wherever it matters most: on a JSON column every\n * suggestion built from the field name alone reads the encoded string rather\n * than what is in it. These are derived from the sampled value, so the decoder\n * they carry is the one that value actually needs — which is the same mistake\n * this whole panel exists to stop the author making.\n *\n * The syntax is gomplate's own, verified against its CEL reference: the\n * comprehension macros (map/filter), and `fold` with the `merge` helper for\n * folding a key/value list into a map. Ranges are wrapped in `dyn(...)` because\n * the engine declares every binding as `any` and a comprehension needs a\n * concrete list to walk.\n */\nexport function celExamplesFor(accessor: string, value: unknown): CelExample[] {\n  const inner = decoded(value);\n  const range = `dyn(${accessor})`;\n\n  if (isKeyValueList(inner)) {\n    const sample = String(inner[0]?.[\"key\"] ?? \"key\");\n    // A fold into a map rather than filter-then-index: a missing key reads as\n    // absent, where indexing an empty filter result is a hard error.\n    const asMap = `${range}.fold(e, acc, merge(acc, {e.key: e.value}))`;\n    return [\n      { label: `Read ${sample}`, expression: `${asMap}[${JSON.stringify(sample)}]` },\n      // The map itself has to be encoded to leave the engine: a CEL map is a\n      // map[ref.Val]ref.Val, which the response cannot serialize. Indexing one\n      // yields a scalar and needs no such call, which is why only this example\n      // carries it.\n      { label: \"Fold every entry into a map\", expression: `${asMap}.toJSON()` },\n      { label: \"List the keys\", expression: `${range}.map(e, e.key)` },\n      { label: \"Keep the whole list\", expression: accessor },\n    ];\n  }\n\n  if (Array.isArray(inner)) {\n    const field = Object.keys((inner[0] ?? {}) as Record<string, unknown>)[0];\n    return [\n      { label: \"Take the first entry\", expression: `${accessor}[0]` },\n      { label: \"Count the entries\", expression: `size(${accessor})` },\n      ...(field\n        ? [{ label: `Pull ${field} from each`, expression: `${range}.map(e, e.${field})` }]\n        : []),\n      { label: \"Keep the whole list\", expression: accessor },\n    ];\n  }\n\n  if (inner !== null && typeof inner === \"object\") {\n    const field = Object.keys(inner as Record<string, unknown>)[0];\n    return [\n      ...(field\n        ? [\n            { label: `Read ${field}`, expression: `${accessor}.${field}` },\n            {\n              label: `Default ${field} when missing`,\n              expression: `has(${accessor}.${field}) ? ${accessor}.${field} : \"\"`,\n            },\n          ]\n        : []),\n      { label: \"List the keys\", expression: `${accessor}.keys()` },\n      { label: \"Keep the whole object\", expression: accessor },\n    ];\n  }\n\n  return [\n    { label: \"Read it\", expression: accessor },\n    { label: \"Convert to text\", expression: `string(${accessor})` },\n    ...(typeof inner === \"number\"\n      ? [{ label: \"Scale by 1,000\", expression: `${accessor} / 1000.0` }]\n      : []),\n  ];\n}\n"],"names":["celEvaluator","fetchJSON","profileApiPath"],"mappings":"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"}

package/dist/profiles/cel/celExpression.d.ts

@@ -0,0 +1,138 @@
+/**
+ * The three binding environments a profile's CEL can compile against.
+ *
+ * The schema tags each CEL field with the one it belongs to
+ * (`x-clicky-cel-scope`), because the document itself does not record it: a
+ * column's expression and a processor's `set` are two strings in the same YAML
+ * that see different variables.
+ */
+export type CelScope = "row" | "batch" | "boundary";
+/**
+ * The `x-clicky-component` hint the profile schema tags every CEL field with, so
+ * the form offers an editor that knows the bindings and can evaluate rather than
+ * a bare input. Mirrors query/schema.celEditorComponent.
+ */
+export declare const CEL_EDITOR_WIDGET = "cel-editor";
+export type CelResult = {
+    index: number;
+    value?: unknown;
+    type?: string;
+    error?: string;
+};
+export type CelResponse = {
+    results: CelResult[];
+    error?: string;
+};
+export type CelRequest = {
+    cel: string;
+    scope: CelScope;
+    rows: unknown[];
+    keep?: string;
+};
+/** What runs an expression for the editor. See {@link evaluateCel}. */
+export type CelEvaluator = (request: CelRequest) => Promise<CelResponse>;
+/**
+ * Evaluates an expression against the sampled rows, once per row.
+ *
+ * It has to be run by the engine that will run it for real, or the preview would
+ * confidently disagree with the column it previews — CEL here is null-safe in
+ * ways a browser reimplementation would not reproduce. The rows travel up with
+ * the request because the caller already sampled them.
+ *
+ * Which engine that is belongs to the host: the default posts to commons-db's
+ * profile service at the configured mount, and a host whose expressions are
+ * evaluated somewhere else — a different route, an RPC, a WASM build running in
+ * the tab — supplies its own through `configureProfiles({ celEvaluator })`
+ * rather than forking the editor.
+ */
+export declare function evaluateCel(request: CelRequest): Promise<CelResponse>;
+export type CelCoverage = {
+    /** Rows that produced a usable value. */
+    ok: number;
+    /** Rows the expression read nothing from. */
+    empty: number;
+    /** Rows where evaluation itself failed. */
+    failed: number;
+    /** Indices of rows that produced nothing usable, in row order. */
+    barren: number[];
+    /** The distinct result types seen, so a column that is sometimes a string shows. */
+    types: string[];
+};
+/**
+ * What an expression did across the whole sample.
+ *
+ * `empty` is deliberately not folded into `ok`. An out-of-range index or a
+ * missing field does not throw in this engine — it reads as null — so the
+ * expression that is wrong about most of the data still returns cleanly, and
+ * counting those rows as successes is exactly the mistake this view exists to
+ * prevent.
+ */
+export declare function coverage(results: CelResult[]): CelCoverage;
+/**
+ * The next row worth looking at after `from`, wrapping.
+ *
+ * An author works from the rows on screen and the rows an expression reads
+ * nothing from are, by definition, ones they have not looked at — so the editor
+ * has to be able to go and find them.
+ */
+export declare function nextBarren(coverageResult: CelCoverage, from: number): number | undefined;
+/** True when the expression is safe to apply: every sampled row evaluated. */
+export declare function isClean(coverageResult: CelCoverage): boolean;
+/** `^[A-Za-z_][A-Za-z0-9_]*$` — the rule the engine flattens a row key by. */
+export declare function isIdentifier(key: string): boolean;
+export type Binding = {
+    name: string;
+    detail: string;
+    value?: unknown;
+};
+/**
+ * What an expression may name in `scope`.
+ *
+ * Only `row` and `span` are fixed in the row scope — every other name comes from
+ * the data, because the engine binds each row key that is a valid identifier as
+ * a bare variable. A key that is not one, like `@timestamp`, is reachable only
+ * through `row`, and the palette says so by omission rather than offering a name
+ * that will not compile.
+ */
+export declare function bindingsFor(scope: CelScope, row: Record<string, unknown> | undefined): Binding[];
+/** Row keys that exist but cannot be named directly. */
+export declare function unreachableKeys(row: Record<string, unknown> | undefined): string[];
+/**
+ * A failure the author can act on, read out of the engine's own words.
+ *
+ * The engine reports in the vocabulary of the Go library underneath it, so
+ * decoding an array with `.JSON()` — a mistake the type system cannot catch,
+ * because both decoders take a string — comes back as a YAML type name and the
+ * entire offending value inline. Neither says what to do.
+ */
+export type CelFailure = {
+    /** What went wrong, in the author's terms. */
+    message: string;
+    /** The draft rewritten to fix it, when the fix is unambiguous. */
+    fix?: string;
+    /** The engine's own words, kept for a failure this cannot explain. */
+    raw: string;
+};
+export declare function explainCelError(error: string, draft: string): CelFailure;
+/** An example expression the author can drop into the draft. */
+export type CelExample = {
+    label: string;
+    expression: string;
+};
+/**
+ * Examples that fit the value in front of the author.
+ *
+ * A fixed list is wrong wherever it matters most: on a JSON column every
+ * suggestion built from the field name alone reads the encoded string rather
+ * than what is in it. These are derived from the sampled value, so the decoder
+ * they carry is the one that value actually needs — which is the same mistake
+ * this whole panel exists to stop the author making.
+ *
+ * The syntax is gomplate's own, verified against its CEL reference: the
+ * comprehension macros (map/filter), and `fold` with the `merge` helper for
+ * folding a key/value list into a map. Ranges are wrapped in `dyn(...)` because
+ * the engine declares every binding as `any` and a comprehension needs a
+ * concrete list to walk.
+ */
+export declare function celExamplesFor(accessor: string, value: unknown): CelExample[];
+//# sourceMappingURL=celExpression.d.ts.map

package/dist/profiles/cel/celExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"celExpression.d.ts","sourceRoot":"","sources":["../../../src/profiles/cel/celExpression.ts"],"names":[],"mappings":"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"}

package/dist/profiles/cel/celExpression.js

@@ -0,0 +1,174 @@
+import { fetchJSON } from "../connections/connectionBrowserModel.js";
+import { profileApiPath, celEvaluator } from "../profileApi.js";
+const CEL_EDITOR_WIDGET = "cel-editor";
+function evaluateCel(request) {
+  const configured = celEvaluator();
+  if (configured) return configured(request);
+  return fetchJSON(profileApiPath("profile/sample/expression"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(request)
+  });
+}
+function coverage(results) {
+  const types = /* @__PURE__ */ new Set();
+  const barren = [];
+  let ok = 0;
+  let empty = 0;
+  let failed = 0;
+  for (const result of results) {
+    if (result.error) {
+      failed += 1;
+      barren.push(result.index);
+      continue;
+    }
+    if (result.value === null || result.value === void 0) {
+      empty += 1;
+      barren.push(result.index);
+      continue;
+    }
+    ok += 1;
+    if (result.type) types.add(result.type);
+  }
+  return { ok, empty, failed, barren, types: [...types].sort() };
+}
+function nextBarren(coverageResult, from) {
+  return coverageResult.barren.find((index) => index > from) ?? coverageResult.barren[0];
+}
+function isClean(coverageResult) {
+  return coverageResult.failed === 0 && coverageResult.empty === 0;
+}
+function isIdentifier(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+function bindingsFor(scope, row) {
+  if (scope === "batch") {
+    return [
+      { name: "batch", detail: "list · the grouped rows, oldest first" },
+      { name: "first", detail: "map · batch[0]" },
+      { name: "last", detail: "map · the final row of the batch" },
+      { name: "count", detail: "int · how many rows collapsed" },
+      { name: "row", detail: "map · the kept row" }
+    ];
+  }
+  if (scope === "boundary") {
+    return [
+      { name: "row", detail: "map · the row being judged" },
+      { name: "prev", detail: "map · the row above it" },
+      { name: "index", detail: "int · position in the result" }
+    ];
+  }
+  const fixed = [
+    { name: "row", detail: "map · the whole row" },
+    { name: "span", detail: "map · the same row, for trace profiles" }
+  ];
+  if (!row) return fixed;
+  const flattened = Object.keys(row).filter(isIdentifier).filter((key) => key !== "row" && key !== "span").sort().map((key) => ({ name: key, detail: `bound bare and as row.${key}`, value: row[key] }));
+  return [...fixed, ...flattened];
+}
+function unreachableKeys(row) {
+  return Object.keys(row ?? {}).filter((key) => !isIdentifier(key));
+}
+const RAW_ERROR_LIMIT = 240;
+function elide(text, limit = RAW_ERROR_LIMIT) {
+  if (text.length <= limit) return text;
+  const head = Math.ceil((limit - 1) / 2);
+  return `${text.slice(0, head)}…${text.slice(text.length - (limit - 1 - head))}`;
+}
+const ARRAY_INTO_OBJECT = /cannot unmarshal\s+!!seq\s+into\s+map\[string\]interface\s*\{\s*\}/;
+const OBJECT_INTO_ARRAY = /cannot unmarshal\s+!!map\s+into\s+\[\]interface\s*\{\s*\}/;
+function explainCelError(error, draft) {
+  const raw = elide(error);
+  if (ARRAY_INTO_OBJECT.test(error)) {
+    const failure = {
+      message: "That value is a JSON array. JSON() decodes an object — use JSONArray(), then index or filter it.",
+      raw
+    };
+    if (draft.includes(".JSON()")) failure.fix = draft.replaceAll(".JSON()", ".JSONArray()");
+    return failure;
+  }
+  if (OBJECT_INTO_ARRAY.test(error)) {
+    const failure = {
+      message: "That value is a JSON object. JSONArray() decodes a list — use JSON().",
+      raw
+    };
+    if (draft.includes(".JSONArray()")) failure.fix = draft.replaceAll(".JSONArray()", ".JSON()");
+    return failure;
+  }
+  return { message: raw, raw };
+}
+function isKeyValueList(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(
+    (entry) => entry !== null && typeof entry === "object" && "key" in entry && "value" in entry
+  );
+}
+function decoded(value) {
+  if (typeof value !== "string") return value;
+  const text = value.trim();
+  if (!text.startsWith("{") && !text.startsWith("[")) return value;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return value;
+  }
+}
+function celExamplesFor(accessor, value) {
+  var _a;
+  const inner = decoded(value);
+  const range = `dyn(${accessor})`;
+  if (isKeyValueList(inner)) {
+    const sample = String(((_a = inner[0]) == null ? void 0 : _a["key"]) ?? "key");
+    const asMap = `${range}.fold(e, acc, merge(acc, {e.key: e.value}))`;
+    return [
+      { label: `Read ${sample}`, expression: `${asMap}[${JSON.stringify(sample)}]` },
+      // The map itself has to be encoded to leave the engine: a CEL map is a
+      // map[ref.Val]ref.Val, which the response cannot serialize. Indexing one
+      // yields a scalar and needs no such call, which is why only this example
+      // carries it.
+      { label: "Fold every entry into a map", expression: `${asMap}.toJSON()` },
+      { label: "List the keys", expression: `${range}.map(e, e.key)` },
+      { label: "Keep the whole list", expression: accessor }
+    ];
+  }
+  if (Array.isArray(inner)) {
+    const field = Object.keys(inner[0] ?? {})[0];
+    return [
+      { label: "Take the first entry", expression: `${accessor}[0]` },
+      { label: "Count the entries", expression: `size(${accessor})` },
+      ...field ? [{ label: `Pull ${field} from each`, expression: `${range}.map(e, e.${field})` }] : [],
+      { label: "Keep the whole list", expression: accessor }
+    ];
+  }
+  if (inner !== null && typeof inner === "object") {
+    const field = Object.keys(inner)[0];
+    return [
+      ...field ? [
+        { label: `Read ${field}`, expression: `${accessor}.${field}` },
+        {
+          label: `Default ${field} when missing`,
+          expression: `has(${accessor}.${field}) ? ${accessor}.${field} : ""`
+        }
+      ] : [],
+      { label: "List the keys", expression: `${accessor}.keys()` },
+      { label: "Keep the whole object", expression: accessor }
+    ];
+  }
+  return [
+    { label: "Read it", expression: accessor },
+    { label: "Convert to text", expression: `string(${accessor})` },
+    ...typeof inner === "number" ? [{ label: "Scale by 1,000", expression: `${accessor} / 1000.0` }] : []
+  ];
+}
+export {
+  CEL_EDITOR_WIDGET,
+  bindingsFor,
+  celExamplesFor,
+  coverage,
+  evaluateCel,
+  explainCelError,
+  isClean,
+  isIdentifier,
+  nextBarren,
+  unreachableKeys
+};
+//# sourceMappingURL=celExpression.js.map

package/dist/profiles/cel/celExpression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"celExpression.js","sources":["../../../src/profiles/cel/celExpression.ts"],"sourcesContent":["import { fetchJSON } from \"../connections/connectionBrowserModel\";\nimport { celEvaluator, profileApiPath } from \"../profileApi\";\n\n/**\n * The three binding environments a profile's CEL can compile against.\n *\n * The schema tags each CEL field with the one it belongs to\n * (`x-clicky-cel-scope`), because the document itself does not record it: a\n * column's expression and a processor's `set` are two strings in the same YAML\n * that see different variables.\n */\nexport type CelScope = \"row\" | \"batch\" | \"boundary\";\n\n/**\n * The `x-clicky-component` hint the profile schema tags every CEL field with, so\n * the form offers an editor that knows the bindings and can evaluate rather than\n * a bare input. Mirrors query/schema.celEditorComponent.\n */\nexport const CEL_EDITOR_WIDGET = \"cel-editor\";\n\nexport type CelResult = {\n  index: number;\n  value?: unknown;\n  type?: string;\n  error?: string;\n};\n\nexport type CelResponse = {\n  results: CelResult[];\n  error?: string;\n};\n\nexport type CelRequest = {\n  cel: string;\n  scope: CelScope;\n  rows: unknown[];\n  keep?: string;\n};\n\n/** What runs an expression for the editor. See {@link evaluateCel}. */\nexport type CelEvaluator = (request: CelRequest) => Promise<CelResponse>;\n\n/**\n * Evaluates an expression against the sampled rows, once per row.\n *\n * It has to be run by the engine that will run it for real, or the preview would\n * confidently disagree with the column it previews — CEL here is null-safe in\n * ways a browser reimplementation would not reproduce. The rows travel up with\n * the request because the caller already sampled them.\n *\n * Which engine that is belongs to the host: the default posts to commons-db's\n * profile service at the configured mount, and a host whose expressions are\n * evaluated somewhere else — a different route, an RPC, a WASM build running in\n * the tab — supplies its own through `configureProfiles({ celEvaluator })`\n * rather than forking the editor.\n */\nexport function evaluateCel(request: CelRequest): Promise<CelResponse> {\n  const configured = celEvaluator();\n  if (configured) return configured(request);\n  return fetchJSON<CelResponse>(profileApiPath(\"profile/sample/expression\"), {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify(request),\n  });\n}\n\nexport type CelCoverage = {\n  /** Rows that produced a usable value. */\n  ok: number;\n  /** Rows the expression read nothing from. */\n  empty: number;\n  /** Rows where evaluation itself failed. */\n  failed: number;\n  /** Indices of rows that produced nothing usable, in row order. */\n  barren: number[];\n  /** The distinct result types seen, so a column that is sometimes a string shows. */\n  types: string[];\n};\n\n/**\n * What an expression did across the whole sample.\n *\n * `empty` is deliberately not folded into `ok`. An out-of-range index or a\n * missing field does not throw in this engine — it reads as null — so the\n * expression that is wrong about most of the data still returns cleanly, and\n * counting those rows as successes is exactly the mistake this view exists to\n * prevent.\n */\nexport function coverage(results: CelResult[]): CelCoverage {\n  const types = new Set<string>();\n  const barren: number[] = [];\n  let ok = 0;\n  let empty = 0;\n  let failed = 0;\n\n  for (const result of results) {\n    if (result.error) {\n      failed += 1;\n      barren.push(result.index);\n      continue;\n    }\n    if (result.value === null || result.value === undefined) {\n      empty += 1;\n      barren.push(result.index);\n      continue;\n    }\n    ok += 1;\n    if (result.type) types.add(result.type);\n  }\n\n  return { ok, empty, failed, barren, types: [...types].sort() };\n}\n\n/**\n * The next row worth looking at after `from`, wrapping.\n *\n * An author works from the rows on screen and the rows an expression reads\n * nothing from are, by definition, ones they have not looked at — so the editor\n * has to be able to go and find them.\n */\nexport function nextBarren(coverageResult: CelCoverage, from: number): number | undefined {\n  return coverageResult.barren.find((index) => index > from) ?? coverageResult.barren[0];\n}\n\n/** True when the expression is safe to apply: every sampled row evaluated. */\nexport function isClean(coverageResult: CelCoverage): boolean {\n  return coverageResult.failed === 0 && coverageResult.empty === 0;\n}\n\n/** `^[A-Za-z_][A-Za-z0-9_]*$` — the rule the engine flattens a row key by. */\nexport function isIdentifier(key: string): boolean {\n  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);\n}\n\nexport type Binding = { name: string; detail: string; value?: unknown };\n\n/**\n * What an expression may name in `scope`.\n *\n * Only `row` and `span` are fixed in the row scope — every other name comes from\n * the data, because the engine binds each row key that is a valid identifier as\n * a bare variable. A key that is not one, like `@timestamp`, is reachable only\n * through `row`, and the palette says so by omission rather than offering a name\n * that will not compile.\n */\nexport function bindingsFor(scope: CelScope, row: Record<string, unknown> | undefined): Binding[] {\n  if (scope === \"batch\") {\n    return [\n      { name: \"batch\", detail: \"list · the grouped rows, oldest first\" },\n      { name: \"first\", detail: \"map · batch[0]\" },\n      { name: \"last\", detail: \"map · the final row of the batch\" },\n      { name: \"count\", detail: \"int · how many rows collapsed\" },\n      { name: \"row\", detail: \"map · the kept row\" },\n    ];\n  }\n  if (scope === \"boundary\") {\n    return [\n      { name: \"row\", detail: \"map · the row being judged\" },\n      { name: \"prev\", detail: \"map · the row above it\" },\n      { name: \"index\", detail: \"int · position in the result\" },\n    ];\n  }\n\n  const fixed: Binding[] = [\n    { name: \"row\", detail: \"map · the whole row\" },\n    { name: \"span\", detail: \"map · the same row, for trace profiles\" },\n  ];\n  if (!row) return fixed;\n\n  const flattened = Object.keys(row)\n    .filter(isIdentifier)\n    .filter((key) => key !== \"row\" && key !== \"span\")\n    .sort()\n    .map((key) => ({ name: key, detail: `bound bare and as row.${key}`, value: row[key] }));\n\n  return [...fixed, ...flattened];\n}\n\n/** Row keys that exist but cannot be named directly. */\nexport function unreachableKeys(row: Record<string, unknown> | undefined): string[] {\n  return Object.keys(row ?? {}).filter((key) => !isIdentifier(key));\n}\n\n/**\n * A failure the author can act on, read out of the engine's own words.\n *\n * The engine reports in the vocabulary of the Go library underneath it, so\n * decoding an array with `.JSON()` — a mistake the type system cannot catch,\n * because both decoders take a string — comes back as a YAML type name and the\n * entire offending value inline. Neither says what to do.\n */\nexport type CelFailure = {\n  /** What went wrong, in the author's terms. */\n  message: string;\n  /** The draft rewritten to fix it, when the fix is unambiguous. */\n  fix?: string;\n  /** The engine's own words, kept for a failure this cannot explain. */\n  raw: string;\n};\n\n/** How much of an error is worth showing before it buries the dialog. */\nconst RAW_ERROR_LIMIT = 240;\n\n/**\n * Shortens an error from the middle.\n *\n * Both ends carry the meaning — the prefix names the operation that failed and\n * the suffix names the failure — and it is the value interpolated between them\n * that runs to kilobytes. Trimming the tail would throw away the diagnosis and\n * keep the payload, which is the wrong half.\n */\nfunction elide(text: string, limit = RAW_ERROR_LIMIT): string {\n  if (text.length <= limit) return text;\n  const head = Math.ceil((limit - 1) / 2);\n  return `${text.slice(0, head)}…${text.slice(text.length - (limit - 1 - head))}`;\n}\n\n/**\n * `.JSON()` decodes an object; the value was an array. The signature is the Go\n * map type the decode targeted — matched on that rather than on the message\n * around it, which carries the whole value and so is never stable.\n */\nconst ARRAY_INTO_OBJECT = /cannot unmarshal\\s+!!seq\\s+into\\s+map\\[string\\]interface\\s*\\{\\s*\\}/;\n\n/** Conversely: `.JSONArray()` on an object. */\nconst OBJECT_INTO_ARRAY = /cannot unmarshal\\s+!!map\\s+into\\s+\\[\\]interface\\s*\\{\\s*\\}/;\n\nexport function explainCelError(error: string, draft: string): CelFailure {\n  const raw = elide(error);\n\n  if (ARRAY_INTO_OBJECT.test(error)) {\n    const failure: CelFailure = {\n      message:\n        \"That value is a JSON array. JSON() decodes an object — use JSONArray(), then index or filter it.\",\n      raw,\n    };\n    if (draft.includes(\".JSON()\")) failure.fix = draft.replaceAll(\".JSON()\", \".JSONArray()\");\n    return failure;\n  }\n\n  if (OBJECT_INTO_ARRAY.test(error)) {\n    const failure: CelFailure = {\n      message: \"That value is a JSON object. JSONArray() decodes a list — use JSON().\",\n      raw,\n    };\n    if (draft.includes(\".JSONArray()\")) failure.fix = draft.replaceAll(\".JSONArray()\", \".JSON()\");\n    return failure;\n  }\n\n  return { message: raw, raw };\n}\n\n/** An example expression the author can drop into the draft. */\nexport type CelExample = { label: string; expression: string };\n\n/** Whether a list looks like OpenTelemetry's `[{key, type, value}]` tag shape. */\nfunction isKeyValueList(value: unknown): value is Array<Record<string, unknown>> {\n  return (\n    Array.isArray(value) &&\n    value.length > 0 &&\n    value.every(\n      (entry) =>\n        entry !== null && typeof entry === \"object\" && \"key\" in entry && \"value\" in entry,\n    )\n  );\n}\n\n/** The value behind an accessor, decoded when the column holds JSON as text. */\nfunction decoded(value: unknown): unknown {\n  if (typeof value !== \"string\") return value;\n  const text = value.trim();\n  if (!text.startsWith(\"{\") && !text.startsWith(\"[\")) return value;\n  try {\n    return JSON.parse(text) as unknown;\n  } catch {\n    return value;\n  }\n}\n\n/**\n * Examples that fit the value in front of the author.\n *\n * A fixed list is wrong wherever it matters most: on a JSON column every\n * suggestion built from the field name alone reads the encoded string rather\n * than what is in it. These are derived from the sampled value, so the decoder\n * they carry is the one that value actually needs — which is the same mistake\n * this whole panel exists to stop the author making.\n *\n * The syntax is gomplate's own, verified against its CEL reference: the\n * comprehension macros (map/filter), and `fold` with the `merge` helper for\n * folding a key/value list into a map. Ranges are wrapped in `dyn(...)` because\n * the engine declares every binding as `any` and a comprehension needs a\n * concrete list to walk.\n */\nexport function celExamplesFor(accessor: string, value: unknown): CelExample[] {\n  const inner = decoded(value);\n  const range = `dyn(${accessor})`;\n\n  if (isKeyValueList(inner)) {\n    const sample = String(inner[0]?.[\"key\"] ?? \"key\");\n    // A fold into a map rather than filter-then-index: a missing key reads as\n    // absent, where indexing an empty filter result is a hard error.\n    const asMap = `${range}.fold(e, acc, merge(acc, {e.key: e.value}))`;\n    return [\n      { label: `Read ${sample}`, expression: `${asMap}[${JSON.stringify(sample)}]` },\n      // The map itself has to be encoded to leave the engine: a CEL map is a\n      // map[ref.Val]ref.Val, which the response cannot serialize. Indexing one\n      // yields a scalar and needs no such call, which is why only this example\n      // carries it.\n      { label: \"Fold every entry into a map\", expression: `${asMap}.toJSON()` },\n      { label: \"List the keys\", expression: `${range}.map(e, e.key)` },\n      { label: \"Keep the whole list\", expression: accessor },\n    ];\n  }\n\n  if (Array.isArray(inner)) {\n    const field = Object.keys((inner[0] ?? {}) as Record<string, unknown>)[0];\n    return [\n      { label: \"Take the first entry\", expression: `${accessor}[0]` },\n      { label: \"Count the entries\", expression: `size(${accessor})` },\n      ...(field\n        ? [{ label: `Pull ${field} from each`, expression: `${range}.map(e, e.${field})` }]\n        : []),\n      { label: \"Keep the whole list\", expression: accessor },\n    ];\n  }\n\n  if (inner !== null && typeof inner === \"object\") {\n    const field = Object.keys(inner as Record<string, unknown>)[0];\n    return [\n      ...(field\n        ? [\n            { label: `Read ${field}`, expression: `${accessor}.${field}` },\n            {\n              label: `Default ${field} when missing`,\n              expression: `has(${accessor}.${field}) ? ${accessor}.${field} : \"\"`,\n            },\n          ]\n        : []),\n      { label: \"List the keys\", expression: `${accessor}.keys()` },\n      { label: \"Keep the whole object\", expression: accessor },\n    ];\n  }\n\n  return [\n    { label: \"Read it\", expression: accessor },\n    { label: \"Convert to text\", expression: `string(${accessor})` },\n    ...(typeof inner === \"number\"\n      ? [{ label: \"Scale by 1,000\", expression: `${accessor} / 1000.0` }]\n      : []),\n  ];\n}\n"],"names":[],"mappings":"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"}

package/dist/profiles/cel/celPath.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsonPathTree = require("../../components/jsonPathTree.cjs");
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function appendSegment(accessor, segment) {
+  if (typeof segment === "number") return `${accessor}[${segment}]`;
+  return IDENTIFIER.test(segment) ? `${accessor}.${segment}` : `${accessor}[${JSON.stringify(segment)}]`;
+}
+function walk(base, path) {
+  return (jsonPathTree.literalSegments(path) ?? []).reduce(appendSegment, base);
+}
+function celFieldAccess(name) {
+  if (IDENTIFIER.test(name)) {
+    return { reference: `row.${name}`, presence: `has(row.${name})` };
+  }
+  const key = JSON.stringify(name);
+  return { reference: `row[${key}]`, presence: `${key} in row` };
+}
+function celDecoder(kind) {
+  return kind === "array" ? ".JSONArray()" : ".JSON()";
+}
+function decodedKind(value) {
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  if (!text.startsWith("{") && !text.startsWith("[")) return void 0;
+  try {
+    const parsed = JSON.parse(text);
+    if (Array.isArray(parsed)) return "array";
+    return parsed !== null && typeof parsed === "object" ? "object" : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function originPrefix(origin, base) {
+  if (!origin) return base;
+  return walk(originPrefix(origin.outer, base), origin.path) + celDecoder(origin.kind);
+}
+function celPathFor(node, base = "row") {
+  const reached = walk(originPrefix(node.origin, base), node.path);
+  const kind = decodedKind(node.value);
+  return kind === void 0 ? reached : reached + celDecoder(kind);
+}
+exports.celDecoder = celDecoder;
+exports.celFieldAccess = celFieldAccess;
+exports.celPathFor = celPathFor;
+exports.decodedKind = decodedKind;
+//# sourceMappingURL=celPath.cjs.map

package/dist/profiles/cel/celPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"celPath.cjs","sources":["../../../src/profiles/cel/celPath.ts"],"sourcesContent":["/**\n * Turning a browsed JSON node into the CEL that reaches it.\n *\n * The tree behind the editor's scope panel descends into a column that holds\n * JSON as text (see `createLazyJSONPathTree`), so a path can cross a boundary\n * that CEL cannot cross implicitly: reaching inside an encoded column means\n * decoding it first, and the decoder depends on what is in there — `.JSON()`\n * reads an object, `.JSONArray()` reads an array, and calling the wrong one\n * fails with a Go type name rather than an explanation.\n *\n * That is the whole reason this module exists. The tree already knows which\n * side of the boundary a node is on and what shape was decoded, so the accessor\n * it hands back can carry the right decoder instead of leaving the author to\n * guess it.\n */\n\nimport {\n  literalSegments,\n  type JSONPathNode,\n  type JSONPathOrigin,\n} from \"../../components/jsonPathTree\";\n\n/** `^[A-Za-z_][A-Za-z0-9_]*$` — the keys CEL can read with a dot. */\nconst IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;\n\n/**\n * One path segment appended to an accessor.\n *\n * A key that is not an identifier is indexed rather than dotted, and quoted by\n * JSON.stringify — hand-rolled quoting is what turns a key containing a newline\n * or a quote into an expression that does not compile.\n */\nfunction appendSegment(accessor: string, segment: string | number): string {\n  if (typeof segment === \"number\") return `${accessor}[${segment}]`;\n  return IDENTIFIER.test(segment)\n    ? `${accessor}.${segment}`\n    : `${accessor}[${JSON.stringify(segment)}]`;\n}\n\n/** Builds an accessor from `base` by walking a literal JSONPath. */\nfunction walk(base: string, path: string): string {\n  return (literalSegments(path) ?? []).reduce(appendSegment, base);\n}\n\n/**\n * How a row key is read, and how its presence is tested.\n *\n * Kept here beside the path builder so the editor speaks one dialect: an\n * example and a clicked path that quote the same key differently read as two\n * languages.\n */\nexport function celFieldAccess(name: string): { reference: string; presence: string } {\n  if (IDENTIFIER.test(name)) {\n    return { reference: `row.${name}`, presence: `has(row.${name})` };\n  }\n  const key = JSON.stringify(name);\n  return { reference: `row[${key}]`, presence: `${key} in row` };\n}\n\n/** The call that crosses a boundary: a list needs JSONArray, a map needs JSON. */\nexport function celDecoder(kind: \"array\" | \"object\"): string {\n  return kind === \"array\" ? \".JSONArray()\" : \".JSON()\";\n}\n\n/** What a JSON-encoded string decodes to, or undefined when it is not one. */\nexport function decodedKind(value: unknown): \"array\" | \"object\" | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const text = value.trim();\n  if (!text.startsWith(\"{\") && !text.startsWith(\"[\")) return undefined;\n  try {\n    const parsed: unknown = JSON.parse(text);\n    if (Array.isArray(parsed)) return \"array\";\n    return parsed !== null && typeof parsed === \"object\" ? \"object\" : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** The chain that reaches a boundary, plus the decoder that crosses it. */\nfunction originPrefix(origin: JSONPathOrigin | undefined, base: string): string {\n  if (!origin) return base;\n  return walk(originPrefix(origin.outer, base), origin.path) + celDecoder(origin.kind);\n}\n\n/**\n * The CEL expression that reads `node` out of the row it was browsed from.\n *\n * Inside a decoded subtree the node's own path restarts at `$`, and its\n * `origin` records every boundary crossed to get there — where each one was and\n * what came out of it. So the accessor is rebuilt boundary by boundary, each\n * contributing the way to the encoded value and the decoder its contents need,\n * which also holds for JSON encoded inside JSON.\n *\n * Selecting a boundary node itself yields the decoded form rather than the raw\n * string: picking a column that holds a document is a request for the document,\n * and naming the decoder here is the whole point of the panel.\n */\nexport function celPathFor(node: JSONPathNode, base = \"row\"): string {\n  const reached = walk(originPrefix(node.origin, base), node.path);\n  const kind = decodedKind(node.value);\n  return kind === undefined ? reached : reached + celDecoder(kind);\n}\n"],"names":["literalSegments"],"mappings":";;;AAuBA,MAAM,aAAa;AASnB,SAAS,cAAc,UAAkB,SAAkC;AACzE,MAAI,OAAO,YAAY,iBAAiB,GAAG,QAAQ,IAAI,OAAO;AAC9D,SAAO,WAAW,KAAK,OAAO,IAC1B,GAAG,QAAQ,IAAI,OAAO,KACtB,GAAG,QAAQ,IAAI,KAAK,UAAU,OAAO,CAAC;AAC5C;AAGA,SAAS,KAAK,MAAc,MAAsB;AAChD,UAAQA,aAAAA,gBAAgB,IAAI,KAAK,CAAA,GAAI,OAAO,eAAe,IAAI;AACjE;AASO,SAAS,eAAe,MAAuD;AACpF,MAAI,WAAW,KAAK,IAAI,GAAG;AACzB,WAAO,EAAE,WAAW,OAAO,IAAI,IAAI,UAAU,WAAW,IAAI,IAAA;AAAA,EAC9D;AACA,QAAM,MAAM,KAAK,UAAU,IAAI;AAC/B,SAAO,EAAE,WAAW,OAAO,GAAG,KAAK,UAAU,GAAG,GAAG,UAAA;AACrD;AAGO,SAAS,WAAW,MAAkC;AAC3D,SAAO,SAAS,UAAU,iBAAiB;AAC7C;AAGO,SAAS,YAAY,OAAgD;AAC1E,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,QAAM,OAAO,MAAM,KAAA;AACnB,MAAI,CAAC,KAAK,WAAW,GAAG,KAAK,CAAC,KAAK,WAAW,GAAG,EAAG,QAAO;AAC3D,MAAI;AACF,UAAM,SAAkB,KAAK,MAAM,IAAI;AACvC,QAAI,MAAM,QAAQ,MAAM,EAAG,QAAO;AAClC,WAAO,WAAW,QAAQ,OAAO,WAAW,WAAW,WAAW;AAAA,EACpE,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAGA,SAAS,aAAa,QAAoC,MAAsB;AAC9E,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO,KAAK,aAAa,OAAO,OAAO,IAAI,GAAG,OAAO,IAAI,IAAI,WAAW,OAAO,IAAI;AACrF;AAeO,SAAS,WAAW,MAAoB,OAAO,OAAe;AACnE,QAAM,UAAU,KAAK,aAAa,KAAK,QAAQ,IAAI,GAAG,KAAK,IAAI;AAC/D,QAAM,OAAO,YAAY,KAAK,KAAK;AACnC,SAAO,SAAS,SAAY,UAAU,UAAU,WAAW,IAAI;AACjE;;;;;"}