@hotmeshio/long-tail 0.14.4 → 0.16.0

package/build/services/orchestrator/condition.js

@@ -33,22 +33,33 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.conditionLT = conditionLT;
+exports.conditionLT = void 0;
+exports.conditional = conditional;
 const hotmesh_1 = require("@hotmeshio/hotmesh");
 const escalation_1 = require("../../types/escalation");
 const interceptorActivities = __importStar(require("../interceptor/activities"));
 const LT_ACTIVITY_QUEUE = 'lt-interceptor';
-/** Fold the schemaVersion sugar into metadata; pass everything else through. */
+/**
+ * Fold the sugar before the config reaches the engine: schemaVersion into the
+ * GIN-indexed metadata (it is a queryable pin), lookups into the unindexed
+ * envelope (they are form plumbing, never a facet). Everything else passes
+ * through.
+ */
 function toEngineConfig(escalation) {
-    if (!escalation || escalation.schemaVersion == null)
+    if (!escalation || (escalation.schemaVersion == null && escalation.lookups == null)) {
         return escalation;
-    const { schemaVersion, ...config } = escalation;
+    }
+    const { schemaVersion, lookups, ...config } = escalation;
+    if (lookups != null)
+        (0, escalation_1.assertLookupRefs)(lookups);
     return {
         ...config,
-        metadata: {
-            ...config.metadata,
-            [escalation_1.ESCALATION_METADATA_KEYS.SCHEMA_VERSION]: schemaVersion,
-        },
+        ...(schemaVersion != null
+            ? { metadata: { ...config.metadata, [escalation_1.ESCALATION_METADATA_KEYS.SCHEMA_VERSION]: schemaVersion } }
+            : {}),
+        ...(lookups != null
+            ? { envelope: { ...config.envelope, [escalation_1.ESCALATION_ENVELOPE_KEYS.LOOKUPS]: lookups } }
+            : {}),
     };
 }
 /**
@@ -64,7 +75,7 @@ function toEngineConfig(escalation) {
  * from the engine automatically.
  *
  * ```typescript
- * const decision = await conditionLT<{ approved: boolean }>(signalId, {
+ * const decision = await conditional<{ approved: boolean }>(signalId, {
  *   role: 'reviewer',
  *   type: 'orderPipeline',
  *   subtype: stationName,
@@ -85,13 +96,27 @@ function toEngineConfig(escalation) {
  * ```typescript
  * import { INTAKE_SCHEMA_VERSION, type IntakeResolverV1 } from './forms';
  *
- * const decision = await conditionLT<IntakeResolverV1>(signalId, {
+ * const decision = await conditional<IntakeResolverV1>(signalId, {
  *   role: INTAKE_ROLE,
  *   description: instructions,
  *   schemaVersion: INTAKE_SCHEMA_VERSION, // the form version this code is written for
  * });
  * ```
  *
+ * **Pin versioned knowledge lookups — option lists the form reads.** Each ref
+ * names an immutable knowledge edition; the resolve UI fetches them once and
+ * the form addresses the content as the `lookup.*` context domain
+ * (`x-lt-options: "lookup.materials.items"`). Evolve the list by writing the
+ * entry (a new version mints automatically) and repinning the literal here.
+ *
+ * ```typescript
+ * const decision = await conditional<PickerResolverV1>(signalId, {
+ *   role: 'catalog-picker',
+ *   description: instructions,
+ *   lookups: [{ domain: 'catalog', key: 'materials', version: 2 }],
+ * });
+ * ```
+ *
  * **With an SLA (hotmesh 0.25.1+) — add `timeout` to the config.** The same
  * single wait arms a resume timer alongside the escalation row: when the timer
  * fires first, this helper returns `false`, the row transitions to
@@ -100,7 +125,7 @@ function toEngineConfig(escalation) {
  * timer is inert.
  *
  * ```typescript
- * const decision = await conditionLT<{ approved: boolean }>(signalId, {
+ * const decision = await conditional<{ approved: boolean }>(signalId, {
  *   role: 'reviewer',
  *   description: instructions,
  *   metadata: { orderId },
@@ -121,7 +146,7 @@ function toEngineConfig(escalation) {
  * ```typescript
  * import type { EscalationResolution } from '@hotmeshio/hotmesh/types';
  *
- * const decision = await conditionLT<{
+ * const decision = await conditional<{
  *   approved: boolean;
  *   $resolution?: EscalationResolution;
  * }>(signalId, { role: 'print-operator' });
@@ -142,10 +167,10 @@ function toEngineConfig(escalation) {
  *
  * ```typescript
  * await activities.ltCreateEscalation({ type: 'approval', role: 'reviewer', metadata: { signal_id: signalId } });
- * const decision = await conditionLT<{ approved: boolean }>(signalId);
+ * const decision = await conditional<{ approved: boolean }>(signalId);
  * ```
  */
-async function conditionLT(signalId, escalation) {
+async function conditional(signalId, escalation) {
     const raw = await hotmesh_1.Durable.workflow.condition(signalId, toEngineConfig(escalation));
     // false = timeout, null = escalation was cancelled — propagate both as-is
     if (raw === null || raw === false)
@@ -176,3 +201,5 @@ async function conditionLT(signalId, escalation) {
     }
     return raw;
 }
+/** @deprecated Alias of {@link conditional}. */
+exports.conditionLT = conditional;

package/build/services/yaml-workflow/durable-compiler/parser.js

@@ -61,7 +61,10 @@ function extractDurablePrimitives(source) {
             primitives.push(prim);
         }
     }
-    // conditionLT (LT-specific wrapper)
+    // conditional / conditionLT (LT-specific wrappers)
+    if (/\bconditional\s*[<(]/.test(source) && !seen.has('conditional')) {
+        primitives.push('conditional');
+    }
     if (/conditionLT/.test(source) && !seen.has('conditionLT')) {
         primitives.push('conditionLT');
     }

package/build/shared/form-validation/ctx-path.d.ts

@@ -0,0 +1,12 @@
+export declare const INTERPOLATION_PATTERN: RegExp;
+/** Whether a token embeds `{{domain.path}}` interpolation segments. */
+export declare function hasInterpolation(token: unknown): token is string;
+/** Resolve a concrete `"domain.path"` (x-lt-bind syntax, `a.b[0].c`) against the context. */
+export declare function resolveCtxPath(path: string, ctx: Record<string, unknown> | undefined): unknown;
+/**
+ * Interpolate every `{{domain.path}}` segment against the context. Returns
+ * the concrete path, or null when any segment resolves to nothing (missing,
+ * null, empty string) or to a non-scalar — an unanswered cascade parent
+ * yields no path, so the dependent field offers nothing.
+ */
+export declare function interpolatePath(template: string, ctx: Record<string, unknown> | undefined): string | null;

package/build/shared/form-validation/ctx-path.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERPOLATION_PATTERN = void 0;
+exports.hasInterpolation = hasInterpolation;
+exports.resolveCtxPath = resolveCtxPath;
+exports.interpolatePath = interpolatePath;
+/**
+ * Context-path resolution shared by every token that names a `"domain.path"`.
+ *
+ * A path may embed `{{domain.path}}` interpolation segments — the same
+ * grammar as x-lt-help tokens — resolved against the live context before the
+ * walk. This is what makes cascading selects work: a field can declare
+ *
+ *   x-lt-options: "lookup.geo.regions.{{resolver.country}}"
+ *
+ * and its option list follows the submitter's country answer, re-resolved
+ * locally on every edit. An unresolved segment means "no concrete path yet",
+ * never a literal placeholder.
+ */
+const x_lt_bind_1 = require("./x-lt-bind");
+exports.INTERPOLATION_PATTERN = /\{\{\s*([^{}]+?)\s*\}\}/g;
+/** Whether a token embeds `{{domain.path}}` interpolation segments. */
+function hasInterpolation(token) {
+    return typeof token === 'string' && /\{\{[^{}]+\}\}/.test(token);
+}
+/** Resolve a concrete `"domain.path"` (x-lt-bind syntax, `a.b[0].c`) against the context. */
+function resolveCtxPath(path, ctx) {
+    if (!ctx)
+        return undefined;
+    const dot = path.indexOf('.');
+    const root = ctx[dot === -1 ? path : path.slice(0, dot)];
+    if (dot === -1)
+        return root;
+    if (root === null || typeof root !== 'object')
+        return undefined;
+    return (0, x_lt_bind_1.getDeep)(root, path.slice(dot + 1));
+}
+/**
+ * Interpolate every `{{domain.path}}` segment against the context. Returns
+ * the concrete path, or null when any segment resolves to nothing (missing,
+ * null, empty string) or to a non-scalar — an unanswered cascade parent
+ * yields no path, so the dependent field offers nothing.
+ */
+function interpolatePath(template, ctx) {
+    let unresolved = false;
+    const concrete = template.replace(exports.INTERPOLATION_PATTERN, (_match, rawPath) => {
+        const value = resolveCtxPath(rawPath, ctx);
+        if (typeof value === 'string' && value.trim().length > 0)
+            return value;
+        if (typeof value === 'number' && Number.isFinite(value))
+            return String(value);
+        unresolved = true;
+        return '';
+    });
+    return unresolved ? null : concrete;
+}

package/build/shared/form-validation/field-validator.d.ts

@@ -9,8 +9,10 @@ interface ChecklistItem {
 }
 /**
  * Resolve a checklist widget's item definitions from its `x-lt-source`
- * "domain.path" against the escalation context. Missing domain/path or a
- * non-array value yields an empty list.
+ * "domain.path" against the escalation context. Paths may embed
+ * `{{domain.path}}` interpolation segments (cascading sources). Missing
+ * domain/path, an unresolved segment, or a non-array value yields an empty
+ * list.
  */
 export declare function resolveChecklistItems(sourcePath: unknown, ctx: Record<string, unknown> | undefined): ChecklistItem[];
 /**

package/build/shared/form-validation/field-validator.js

@@ -6,26 +6,25 @@ exports.validateFieldType = validateFieldType;
 exports.validateFieldConstraints = validateFieldConstraints;
 exports.validateField = validateField;
 const x_lt_options_1 = require("./x-lt-options");
+const ctx_path_1 = require("./ctx-path");
 /**
  * Resolve a checklist widget's item definitions from its `x-lt-source`
- * "domain.path" against the escalation context. Missing domain/path or a
- * non-array value yields an empty list.
+ * "domain.path" against the escalation context. Paths may embed
+ * `{{domain.path}}` interpolation segments (cascading sources). Missing
+ * domain/path, an unresolved segment, or a non-array value yields an empty
+ * list.
  */
 function resolveChecklistItems(sourcePath, ctx) {
     if (typeof sourcePath !== 'string' || !ctx)
         return [];
-    const dot = sourcePath.indexOf('.');
-    if (dot === -1)
-        return [];
-    const domainObj = ctx[sourcePath.slice(0, dot)];
-    if (!domainObj || typeof domainObj !== 'object')
-        return [];
-    let cur = domainObj;
-    for (const p of sourcePath.slice(dot + 1).split('.')) {
-        cur = cur[p];
-        if (cur === undefined)
+    let concrete = sourcePath;
+    if ((0, ctx_path_1.hasInterpolation)(sourcePath)) {
+        const resolved = (0, ctx_path_1.interpolatePath)(sourcePath, ctx);
+        if (resolved === null)
             return [];
+        concrete = resolved;
     }
+    const cur = (0, ctx_path_1.resolveCtxPath)(concrete, ctx);
     return Array.isArray(cur) ? cur : [];
 }
 /**
@@ -97,12 +96,17 @@ function validateFieldConstraints(value, fieldSchema, ctx) {
         return undefined;
     // Option membership — the form's select widget constrains choices; API-first
     // callers are unconstrained, so the effective option list is the contract:
-    // the static enum, or the x-lt-options list resolved from context.
+    // the static enum, or the x-lt-options list resolved from context. An
+    // interpolated list that currently offers nothing fails closed — a stale
+    // cascade child value never submits.
     const allowed = (0, x_lt_options_1.resolveFieldOptions)(fieldSchema, ctx);
-    if (allowed && allowed.length > 0
-        && value !== undefined && value !== null && value !== ''
-        && !allowed.includes(value)) {
-        return `Must be one of: ${allowed.map((v) => String(v)).join(', ')}`;
+    if (allowed !== undefined && value !== undefined && value !== null && value !== '') {
+        if (allowed.length === 0) {
+            return 'No valid options for this selection';
+        }
+        if (!allowed.includes(value)) {
+            return `Must be one of: ${allowed.map((v) => String(v)).join(', ')}`;
+        }
     }
     if (typeof value === 'string') {
         const s = value.trim();

package/build/shared/form-validation/index.d.ts

@@ -16,5 +16,6 @@ export * from './x-lt-show-if';
 export * from './x-lt-require-any';
 export * from './x-lt-require-sum';
 export * from './x-lt-options';
+export * from './ctx-path';
 export * from './field-validator';
 export * from './validate-resolver-payload';

package/build/shared/form-validation/index.js

@@ -32,5 +32,6 @@ __exportStar(require("./x-lt-show-if"), exports);
 __exportStar(require("./x-lt-require-any"), exports);
 __exportStar(require("./x-lt-require-sum"), exports);
 __exportStar(require("./x-lt-options"), exports);
+__exportStar(require("./ctx-path"), exports);
 __exportStar(require("./field-validator"), exports);
 __exportStar(require("./validate-resolver-payload"), exports);

package/build/shared/form-validation/x-lt-help.d.ts

@@ -1,5 +1,5 @@
 /** The token domains a help template may reference. */
-export declare const HELP_DOMAINS: readonly ["escalation", "metadata", "envelope", "payload", "resolver"];
+export declare const HELP_DOMAINS: readonly ["escalation", "metadata", "envelope", "payload", "resolver", "lookup"];
 export type HelpDomain = (typeof HELP_DOMAINS)[number];
 export type HelpTokenContext = Partial<Record<HelpDomain, Record<string, unknown> | null>>;
 /** Replace every `{{domain.path}}` token with its value from the context. */

package/build/shared/form-validation/x-lt-help.js

@@ -16,6 +16,7 @@ exports.defaultHelpMarkdown = defaultHelpMarkdown;
  *   {{envelope.formDefaults.customer.name}}    — the workflow-sent input envelope
  *   {{payload.category}}                       — the escalation context payload
  *   {{resolver.notes}}                         — the submitted resolver payload
+ *   {{lookup.materials.items}}                 — versioned knowledge lookups pinned on the row
  *
  * Paths reuse the x-lt-bind syntax (`a.b[0].c`). A missing value renders as an
  * em dash. `x-lt-context` is accepted as the plain-text fallback source when
@@ -23,7 +24,7 @@ exports.defaultHelpMarkdown = defaultHelpMarkdown;
  */
 const x_lt_bind_1 = require("./x-lt-bind");
 /** The token domains a help template may reference. */
-exports.HELP_DOMAINS = ['escalation', 'metadata', 'envelope', 'payload', 'resolver'];
+exports.HELP_DOMAINS = ['escalation', 'metadata', 'envelope', 'payload', 'resolver', 'lookup'];
 const TOKEN_PATTERN = /\{\{\s*([^{}]+?)\s*\}\}/g;
 const MISSING_VALUE = '—';
 function formatTokenValue(value) {

package/build/shared/form-validation/x-lt-options.d.ts

@@ -1,22 +1,7 @@
-/**
- * x-lt-options — a select's option list resolved from the escalation context.
- * The field-level token names a `"domain.path"`; the value at that path is an
- * array of scalars (strings or numbers) that becomes the field's option list,
- * so one static role form can offer a different legal set per escalation
- * (e.g. `[1..N]` where N rides the envelope).
- *
- *   x-lt-options   "domain.path" — e.g. "envelope.left_quantity_options"
- *
- * A static `enum` takes precedence when both are present — the same
- * static-over-dynamic rule as x-lt-minimum/x-lt-maximum. A path that resolves
- * to nothing, or to no scalar entries, yields no options: the field renders as
- * a plain input for its type and membership is not enforced. Non-scalar
- * entries in a resolved array are dropped.
- */
 export declare const X_LT_OPTIONS = "x-lt-options";
 export type OptionValue = string | number;
 /**
  * The field's effective option list: the static `enum` when present, else the
- * scalars at the token's `"domain.path"`. Undefined when neither yields any.
+ * scalars at the token's `"domain.path"`.
  */
 export declare function resolveFieldOptions(fieldSchema: Record<string, unknown> | null | undefined, ctx: Record<string, unknown> | undefined): OptionValue[] | undefined;

package/build/shared/form-validation/x-lt-options.js

@@ -1,26 +1,37 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.X_LT_OPTIONS = void 0;
+exports.resolveFieldOptions = resolveFieldOptions;
 /**
  * x-lt-options — a select's option list resolved from the escalation context.
  * The field-level token names a `"domain.path"`; the value at that path is an
  * array of scalars (strings or numbers) that becomes the field's option list,
  * so one static role form can offer a different legal set per escalation
- * (e.g. `[1..N]` where N rides the envelope).
+ * (e.g. `[1..N]` where N rides the envelope, or a versioned knowledge lookup
+ * under the `lookup` domain).
  *
  *   x-lt-options   "domain.path" — e.g. "envelope.left_quantity_options"
+ *                  paths may embed {{domain.path}} interpolation segments —
+ *                  e.g. "lookup.geo.regions.{{resolver.country}}" — making
+ *                  the option list follow another answer (cascading selects)
  *
  * A static `enum` takes precedence when both are present — the same
- * static-over-dynamic rule as x-lt-minimum/x-lt-maximum. A path that resolves
- * to nothing, or to no scalar entries, yields no options: the field renders as
- * a plain input for its type and membership is not enforced. Non-scalar
- * entries in a resolved array are dropped.
+ * static-over-dynamic rule as x-lt-minimum/x-lt-maximum. Resolution is a
+ * tri-state:
+ *
+ *   undefined  — no dynamic contract: a plain path that resolves to nothing
+ *                (the field renders as its plain input; membership unenforced)
+ *   []         — a dynamic (interpolated) contract offering nothing YET: the
+ *                select renders disabled and a present value fails membership
+ *   values     — the option list
+ *
+ * Non-scalar entries in a resolved array are dropped.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.X_LT_OPTIONS = void 0;
-exports.resolveFieldOptions = resolveFieldOptions;
+const ctx_path_1 = require("./ctx-path");
 exports.X_LT_OPTIONS = 'x-lt-options';
 /**
  * The field's effective option list: the static `enum` when present, else the
- * scalars at the token's `"domain.path"`. Undefined when neither yields any.
+ * scalars at the token's `"domain.path"`.
  */
 function resolveFieldOptions(fieldSchema, ctx) {
     if (!fieldSchema)
@@ -30,22 +41,23 @@ function resolveFieldOptions(fieldSchema, ctx) {
         return staticEnum;
     }
     const sourcePath = fieldSchema[exports.X_LT_OPTIONS];
-    if (typeof sourcePath !== 'string' || !ctx)
-        return undefined;
-    const dot = sourcePath.indexOf('.');
-    if (dot === -1)
+    if (typeof sourcePath !== 'string')
         return undefined;
-    const domainObj = ctx[sourcePath.slice(0, dot)];
-    if (!domainObj || typeof domainObj !== 'object')
-        return undefined;
-    let cur = domainObj;
-    for (const p of sourcePath.slice(dot + 1).split('.')) {
-        cur = cur[p];
-        if (cur === undefined)
-            return undefined;
+    // Interpolated tokens are a standing contract: even unresolvable, the field
+    // stays a (disabled) select and fails closed. Plain paths keep the legacy
+    // undefined-on-miss reading.
+    const dynamic = (0, ctx_path_1.hasInterpolation)(sourcePath);
+    const miss = dynamic ? [] : undefined;
+    let concrete = sourcePath;
+    if (dynamic) {
+        const resolved = (0, ctx_path_1.interpolatePath)(sourcePath, ctx);
+        if (resolved === null)
+            return miss;
+        concrete = resolved;
     }
+    const cur = (0, ctx_path_1.resolveCtxPath)(concrete, ctx);
     if (!Array.isArray(cur))
-        return undefined;
+        return miss;
     const scalars = cur.filter((v) => typeof v === 'string' || (typeof v === 'number' && Number.isFinite(v)));
-    return scalars.length > 0 ? scalars : undefined;
+    return scalars.length > 0 ? scalars : miss;
 }

package/build/system/activities/knowledge.d.ts

@@ -8,6 +8,7 @@ export declare function storeKnowledge(args: {
     id: string;
     domain: string;
     key: string;
+    current_version: number;
     created: boolean;
     updated_at: string;
 }>;
@@ -51,6 +52,7 @@ export declare function setKnowledgeField(args: {
     id: string;
     domain: string;
     key: string;
+    current_version: number;
     created: boolean;
     updated_at: string;
 }>;
@@ -77,5 +79,6 @@ export declare function appendKnowledge(args: {
     id: string;
     domain: string;
     key: string;
+    current_version: number;
     updated_at: string;
 }>;

package/build/system/activities/knowledge.js

@@ -44,6 +44,7 @@ async function getKnowledge(args) {
             key: row.key,
             data: row.data,
             tags: row.tags,
+            current_version: row.current_version,
             created_at: row.created_at.toISOString(),
             updated_at: row.updated_at.toISOString(),
         };
@@ -66,13 +67,14 @@ async function searchKnowledge(args) {
         const limitIdx = params.length;
         params.push(offset);
         const offsetIdx = params.length;
-        const { rows } = await client.query(`SELECT id, domain, key, data, tags, created_at, updated_at
+        const { rows } = await client.query(`SELECT id, domain, key, data, tags, current_version, created_at, updated_at
        FROM lt_knowledge
        WHERE domain = $1 AND data @> $2::jsonb${tagClause}
        ORDER BY updated_at DESC LIMIT $${limitIdx} OFFSET $${offsetIdx}`, params);
         return {
             entries: rows.map((r) => ({
                 id: r.id, domain: r.domain, key: r.key, data: r.data, tags: r.tags,
+                current_version: r.current_version,
                 created_at: r.created_at.toISOString(), updated_at: r.updated_at.toISOString(),
             })),
             total: countResult.rows[0].total,
@@ -99,12 +101,13 @@ async function listKnowledge(args) {
         const queryParams = [...params, limit, offset];
         const limitIdx = params.length + 1;
         const offsetIdx = params.length + 2;
-        const { rows } = await client.query(`SELECT id, domain, key, data, tags, created_at, updated_at
+        const { rows } = await client.query(`SELECT id, domain, key, data, tags, current_version, created_at, updated_at
        FROM lt_knowledge WHERE domain = $1${extraClauses}
        ORDER BY updated_at DESC LIMIT $${limitIdx} OFFSET $${offsetIdx}`, queryParams);
         return {
             entries: rows.map((r) => ({
                 id: r.id, domain: r.domain, key: r.key, data: r.data, tags: r.tags,
+                current_version: r.current_version,
                 created_at: r.created_at.toISOString(), updated_at: r.updated_at.toISOString(),
             })),
             total: countResult.rows[0].total,

package/build/system/activities/sql.d.ts

@@ -1,12 +1,8 @@
-export declare const UPSERT_KNOWLEDGE = "\n  INSERT INTO lt_knowledge (domain, key, data, tags)\n  VALUES ($1, $2, $3, $4)\n  ON CONFLICT (domain, key) DO UPDATE SET\n    data = CASE\n      WHEN jsonb_typeof(lt_knowledge.data) = 'object'\n      THEN lt_knowledge.data || EXCLUDED.data\n      ELSE EXCLUDED.data\n    END,\n    tags = ARRAY(SELECT DISTINCT unnest(lt_knowledge.tags || EXCLUDED.tags))\n  RETURNING id, domain, key, (xmax = 0) AS created, updated_at";
-export declare const REPLACE_KNOWLEDGE = "\n  INSERT INTO lt_knowledge (domain, key, data, tags)\n  VALUES ($1, $2, $3, $4)\n  ON CONFLICT (domain, key) DO UPDATE SET\n    data = EXCLUDED.data,\n    tags = EXCLUDED.tags\n  RETURNING id, domain, key, (xmax = 0) AS created, updated_at";
-export declare const GET_KNOWLEDGE = "\n  SELECT id, domain, key, data, tags, created_at, updated_at\n  FROM lt_knowledge WHERE domain = $1 AND key = $2";
-export declare const SEARCH_KNOWLEDGE = "\n  SELECT id, domain, key, data, tags, created_at, updated_at\n  FROM lt_knowledge\n  WHERE domain = $1 AND data @> $2::jsonb";
-export declare const COUNT_KNOWLEDGE_SEARCH = "\n  SELECT COUNT(*)::int AS total FROM lt_knowledge\n  WHERE domain = $1 AND data @> $2::jsonb";
-export declare const LIST_KNOWLEDGE = "\n  SELECT id, domain, key, data, tags, created_at, updated_at\n  FROM lt_knowledge WHERE domain = $1";
-export declare const COUNT_KNOWLEDGE_LIST = "\n  SELECT COUNT(*)::int AS total FROM lt_knowledge WHERE domain = $1";
+export declare const UPSERT_KNOWLEDGE = "\n  WITH upserted AS (\n    INSERT INTO lt_knowledge (domain, key, data, tags)\n    VALUES ($1, $2, $3, $4)\n    ON CONFLICT (domain, key) DO UPDATE SET\n      data = CASE\n        WHEN jsonb_typeof(lt_knowledge.data) = 'object'\n        THEN lt_knowledge.data || EXCLUDED.data\n        ELSE EXCLUDED.data\n      END,\n      tags = ARRAY(SELECT DISTINCT unnest(lt_knowledge.tags || EXCLUDED.tags)),\n      current_version = CASE\n        WHEN (CASE\n          WHEN jsonb_typeof(lt_knowledge.data) = 'object'\n          THEN lt_knowledge.data || EXCLUDED.data\n          ELSE EXCLUDED.data\n        END) IS DISTINCT FROM lt_knowledge.data\n        THEN lt_knowledge.current_version + 1\n        ELSE lt_knowledge.current_version\n      END\n    RETURNING id, domain, key, data, tags, current_version, (xmax = 0) AS created, updated_at\n  ), snapshot AS (\n    INSERT INTO lt_knowledge_versions (domain, key, version, data, tags)\n    SELECT domain, key, current_version, data, tags FROM upserted\n    ON CONFLICT (domain, key, version) DO NOTHING\n  )\n  SELECT id, domain, key, current_version, created, updated_at FROM upserted";
+export declare const REPLACE_KNOWLEDGE = "\n  WITH upserted AS (\n    INSERT INTO lt_knowledge (domain, key, data, tags)\n    VALUES ($1, $2, $3, $4)\n    ON CONFLICT (domain, key) DO UPDATE SET\n      data = EXCLUDED.data,\n      tags = EXCLUDED.tags,\n      current_version = CASE\n        WHEN EXCLUDED.data IS DISTINCT FROM lt_knowledge.data\n        THEN lt_knowledge.current_version + 1\n        ELSE lt_knowledge.current_version\n      END\n    RETURNING id, domain, key, data, tags, current_version, (xmax = 0) AS created, updated_at\n  ), snapshot AS (\n    INSERT INTO lt_knowledge_versions (domain, key, version, data, tags)\n    SELECT domain, key, current_version, data, tags FROM upserted\n    ON CONFLICT (domain, key, version) DO NOTHING\n  )\n  SELECT id, domain, key, current_version, created, updated_at FROM upserted";
+export declare const GET_KNOWLEDGE = "\n  SELECT id, domain, key, data, tags, current_version, created_at, updated_at\n  FROM lt_knowledge WHERE domain = $1 AND key = $2";
 export declare const DELETE_KNOWLEDGE = "\n  DELETE FROM lt_knowledge WHERE domain = $1 AND key = $2";
 export declare const LIST_DOMAINS = "\n  SELECT domain, COUNT(*)::int AS count, MAX(updated_at) AS latest\n  FROM lt_knowledge GROUP BY domain ORDER BY latest DESC";
-export declare const SET_KNOWLEDGE_FIELD = "\n  INSERT INTO lt_knowledge (domain, key, data, tags)\n  VALUES ($1, $2, $3::jsonb, $4)\n  ON CONFLICT (domain, key) DO UPDATE SET\n    data = jsonb_set(lt_knowledge.data, $5::text[], $6::jsonb, true),\n    tags = ARRAY(SELECT DISTINCT unnest(lt_knowledge.tags || EXCLUDED.tags))\n  RETURNING id, domain, key, (xmax = 0) AS created, updated_at";
-export declare const REMOVE_KNOWLEDGE_FIELD = "\n  UPDATE lt_knowledge\n  SET data = data #- $3::text[]\n  WHERE domain = $1 AND key = $2\n  RETURNING id, domain, key, updated_at";
-export declare const APPEND_KNOWLEDGE = "\n  INSERT INTO lt_knowledge (domain, key, data)\n  VALUES ($1, $2, $3::jsonb)\n  ON CONFLICT (domain, key) DO UPDATE SET\n    data = CASE\n      WHEN lt_knowledge.data #> $4::text[] IS NULL\n      THEN jsonb_set(lt_knowledge.data, $4::text[], jsonb_build_array($5::jsonb))\n      ELSE jsonb_set(lt_knowledge.data, $4::text[], (lt_knowledge.data #> $4::text[]) || jsonb_build_array($5::jsonb))\n    END\n  RETURNING id, domain, key, updated_at";
+export declare const SET_KNOWLEDGE_FIELD = "\n  WITH upserted AS (\n    INSERT INTO lt_knowledge (domain, key, data, tags)\n    VALUES ($1, $2, $3::jsonb, $4)\n    ON CONFLICT (domain, key) DO UPDATE SET\n      data = jsonb_set(lt_knowledge.data, $5::text[], $6::jsonb, true),\n      tags = ARRAY(SELECT DISTINCT unnest(lt_knowledge.tags || EXCLUDED.tags)),\n      current_version = CASE\n        WHEN jsonb_set(lt_knowledge.data, $5::text[], $6::jsonb, true) IS DISTINCT FROM lt_knowledge.data\n        THEN lt_knowledge.current_version + 1\n        ELSE lt_knowledge.current_version\n      END\n    RETURNING id, domain, key, data, tags, current_version, (xmax = 0) AS created, updated_at\n  ), snapshot AS (\n    INSERT INTO lt_knowledge_versions (domain, key, version, data, tags)\n    SELECT domain, key, current_version, data, tags FROM upserted\n    ON CONFLICT (domain, key, version) DO NOTHING\n  )\n  SELECT id, domain, key, current_version, created, updated_at FROM upserted";
+export declare const REMOVE_KNOWLEDGE_FIELD = "\n  WITH updated AS (\n    UPDATE lt_knowledge\n    SET data = data #- $3::text[],\n        current_version = CASE\n          WHEN data #- $3::text[] IS DISTINCT FROM data\n          THEN current_version + 1\n          ELSE current_version\n        END\n    WHERE domain = $1 AND key = $2\n    RETURNING id, domain, key, data, tags, current_version, updated_at\n  ), snapshot AS (\n    INSERT INTO lt_knowledge_versions (domain, key, version, data, tags)\n    SELECT domain, key, current_version, data, tags FROM updated\n    ON CONFLICT (domain, key, version) DO NOTHING\n  )\n  SELECT id, domain, key, current_version, updated_at FROM updated";
+export declare const APPEND_KNOWLEDGE = "\n  WITH upserted AS (\n    INSERT INTO lt_knowledge (domain, key, data)\n    VALUES ($1, $2, $3::jsonb)\n    ON CONFLICT (domain, key) DO UPDATE SET\n      data = CASE\n        WHEN lt_knowledge.data #> $4::text[] IS NULL\n        THEN jsonb_set(lt_knowledge.data, $4::text[], jsonb_build_array($5::jsonb))\n        ELSE jsonb_set(lt_knowledge.data, $4::text[], (lt_knowledge.data #> $4::text[]) || jsonb_build_array($5::jsonb))\n      END,\n      current_version = lt_knowledge.current_version + 1\n    RETURNING id, domain, key, data, tags, current_version, updated_at\n  ), snapshot AS (\n    INSERT INTO lt_knowledge_versions (domain, key, version, data, tags)\n    SELECT domain, key, current_version, data, tags FROM upserted\n    ON CONFLICT (domain, key, version) DO NOTHING\n  )\n  SELECT id, domain, key, current_version, updated_at FROM upserted";