@qoretechnologies/reqraft 0.10.53 → 0.10.54-pr.115.ge2d364c

package/.claude/CLAUDE.md

@@ -167,6 +167,7 @@ yarn build:test         # Type-check without emit
 
 - `yarn precheck` runs: lint → test → build:test:prod
 - `pre-push` hook enforces: `build:test:prod`, `lint`, `test`
+- CI (`.github/workflows/tests.yml`) runs precheck, build and the full story suite for PRs into `develop` **and** for every push to `develop`. GitHub skips `pull_request` workflows while a PR has merge conflicts, so a conflicting PR gets no test runs until it is rebased or merged up
 - Branch naming: always start with the issue number, e.g. `feature/49_pooled-connections`
 
 ### Versioning — every PR to `develop` MUST bump the version
@@ -201,6 +202,26 @@ yarn build:test         # Type-check without emit
 - Stories are co-located alongside source: `src/hooks/useFetch/useFetch.stories.tsx`
 - Storybook port: **6008**
 - Story + interaction tests run on **Vitest browser mode** (Playwright/Chromium): `yarn test:stories [file-substring]`. Run `yarn install-playwright` once first.
+- **Story network — mocks must follow the instance, and stories must not share connections.**
+  - Build every mock URL with `storyApiUrl(path)` / `storySocketUrl(path)` from
+    `src/stories/storyNetwork.ts`, never a hard-coded `https://hq.qoretechnologies.com:8092/…`.
+    Both mock layers match on host (storybook-addon-mock keys on `host + pathname`,
+    mock-socket on the URL minus its query), so a hard-coded host silently stops matching
+    when `REACT_APP_QORUS_INSTANCE` is overridden and the request goes to the real network.
+  - Requests components make on their own (FormEngine's `system/qorus-type-info`, the
+    expression catalogue `useExpressions` fetches whenever functions are allowed, the
+    reconnect probe `system/pid`) are mocked for every story via `GLOBAL_STORY_MOCK_DATA`
+    (`parameters.mockAddonConfigs.globalMockData`). Add new ones there, not per story file.
+  - A mock `response` must be an object, array or function — a bare number or string fails
+    the addon's validation and the entry is silently never matched (`TStoryMockResponse`
+    enforces this at compile time). The addon compares query-parameter *keys* only, so
+    `system?action=a&context=x` also answers `system?action=b&context=y`.
+  - `.storybook/preview.tsx` resets the shared LSP connections and the expression render
+    client before every story. Do not add per-file `ReqraftWebSocketsManager.closeAll()`
+    calls for LSP isolation.
+  - CI reaches the live hq instance with a valid token, so a story that leaks a real
+    request can pass in CI and hang locally. When a story passes in CI but times out on
+    your machine, look for an unmocked request before anything else.
 - **Visual regression via Qlip** (not Chromatic): the story run captures snapshots through the `qlip` Vitest plugin. Upload is gated on `QLIP_UPLOAD_TOKEN` (`vitest.config.ts`), so **local runs capture but never upload** — PNGs land in `qlip/screenshots/<ts>/stories/auto/<StoryId>.png` (gitignored); read the PNG to verify a visual change. CI (`.github/workflows/tests.yml`) sets the token and uploads a build for dashboard review. The full visual-change flow + the `qlip` MCP review skill live in the imported `stacks/frontend/FRONTEND.md`.
 
 ## Code Patterns & Conventions
@@ -260,6 +281,10 @@ yarn build:test         # Type-check without emit
 | `query()` returning stale data | Pass `cache: false`; POST/DELETE bypass cache automatically |
 | Heartbeat noise in logs | Filter `ev.data === 'pong'` — already done inside `useReqraftWebSocket` |
 | Storage path collisions | Use `includeAppPrefix: true` in `useReqraftStorage` to namespace per app |
+| Story shows FormEngine's loading skeleton / "Connecting to language server…" forever | An unmocked request or a connection inherited from an earlier story — see "Story network" above |
+| "No Preview — Sorry, but you either have no stories…" in a story failure | Not a registration failure: addon-vitest injects Storybook's hidden preview body into every test page, and a failed query's DOM dump prints it. Read the assertion above the dump |
+| A story run stops reporting and never times out (no failure, no output) | The page's main thread is blocked, so the in-page 30s test timer cannot fire — usually a synchronous render loop inside `act()`. Find the story with `--reporter=verbose` (the last ✓ is the one before it), then give Chromium `launchOptions: { args: ['--remote-debugging-port=9333'] }` in `vitest.config.ts` locally, enable `Debugger` over CDP BEFORE the freeze, and `Debugger.pause` once `Runtime.evaluate` stops answering to get the stack. Revert the config afterwards |
+| `yarn test:stories` hangs before any test runs (the port message is incidental) | Seen when the checkout path contains `+` — e.g. an auto-named `.claude/worktrees/fix+name` — while the same tree at a `+`-free path runs normally. Use a path without `+` |
 
 ## File Reference
 

package/.tasks/INDEX.md

@@ -58,6 +58,7 @@ needs phase 1.
 | [RENDER_EXPRESSION_LSP](./RENDER_EXPRESSION_LSP.md) | done pending user verify, branch `feature/render-expression-lsp` — server deployed + live-verified end-to-end 2026-06-10 (final gate 201/201 storybook, 268/268 jest, browser proof of server rendering) | **8th.** Server "Explain" over the LSP: new `dpql/renderExpression` in `QorusLspWebSocketHandler.qc` + `useRenderExpression` swap. Closes EXPRESSION_BUILDER_REPORT Phase D. Design: `design/RENDER_EXPRESSION_TRANSPORT.md`. |
 | [FIELD_STACK_REPORT](./FIELD_STACK_REPORT.md) | done pending user verify (uncommitted) — final gate 234/234 storybook (incl. 37 ported Template/Auto plays), 268/268 jest | **9th.** Verbatim re-port of the IDE's `Field/template.tsx` + `Field/auto.tsx` (the operand layer under the ported builder) + their IDE stories, replacing the from-scratch TemplateField/AutoFormField; closes the `isFunction` operand-flow gap (behavioral difference #4 in EXPRESSION_BUILDER_REPORT). Supersedes the from-scratch implementation from REQRAFT_AUTO_FIELD (its stories/assertions are kept and reconciled). |
 | [BRANCH_REMEDIATION](./BRANCH_REMEDIATION.md) | done pending user verify (uncommitted) — jest 268→356, plays 241→255, lint/tsc clean | **10th.** Burn-down of the 2026-06-10 full-branch audit: tests/stories/API/comment-voice remediation + behavior fixes (Select modal-click collapse, edge-triggered Url, ReqraftLspClient rename, CI auth wiring). Ledger: gitignored `SWEEP.local.md`. |
+| [STORY_NETWORK_ISOLATION](./STORY_NETWORK_ISOLATION.md) | done pending user verify, folded into `fix/per-field-templates` (PR #115), not pushed | **Standalone.** ExpressionField stories failed off-network on `develop` (passed in CI only because CI reaches the live instance): LSP connections leaking across stories, an unhandled socket give-up in `LspSharedConnection`, unmocked background requests, and mock URLs hard-coded to the hq host. |
 | [TEMPLATE_TOKEN_GRAMMAR](./TEMPLATE_TOKEN_GRAMMAR.md) | committed `0ef167c`, in PR (branch `bugfix/template-token-grammar`) — user-verified 2026-08-27; 13/13 unit, 21/21 template plays, qlip PNGs read | **11th (bugfix).** Braced `$data:{…}` state-output refs rehydrate as raw text: canonical token grammar + strict whole-token check + TemplateField renders whole-token values as the picker chip. Twin fix applied in qorus-ide the same day; ships as a normal per-PR patch release (`0.10.37`). |
 | [EXPRESSION_FIELD_SEAMS](./EXPRESSION_FIELD_SEAMS.md) | committed `f5fb2ee`, pushed (branch `bugfix/116_expression-field-seams`) — user-verified 2026-09-07; PR not yet opened | **12th (bugfix).** The `extraActions` seam stopped one hop short of the `ExpressionField` shell hosts mount, and the builder's operand `TemplateField` mounts dropped it again — qorus-ide lost its AI-assist button on every expression card when it adopted the shell ([#116](https://github.com/qoretechnologies/toolkit-react/issues/116)). Forward it through both hops; pin with a nested-operand story; ships as a per-PR patch (`0.10.51`; re-based onto `4860e6e` after #114 published 0.10.50). |
 | [EXPORT_EXPRESSION_BUILDER](./EXPORT_EXPRESSION_BUILDER.md) | committed `0eea9e7`, pushed, PR open (branch `feature/119_export-expression-builder`) | **13th (surface fix).** The barrel exported the `ExpressionField` shell but not the bare `ExpressionBuilder`, so a host mirroring the library's root/nested rule had to deep-import `dist/…/builder` ([#119](https://github.com/qoretechnologies/toolkit-react/issues/119)). Export + a barrel test; ships as `0.10.53`. |

package/.tasks/STORY_NETWORK_ISOLATION.md

@@ -0,0 +1,98 @@
+# Story network isolation — ExpressionField stories fail off-network
+
+**Status:** done pending user verify — folded into `fix/per-field-templates`
+(PR #115) so every open reqraft fix ships in one PR; not yet pushed.
+Originally built and verified on `develop` (stories 479/479, unit 930/930,
+off-network), then re-verified on the combined branch.
+
+## Symptom
+
+`yarn test:stories ExpressionField` failed 6 of 8 on `develop` locally, while the
+same file passed in CI (run 34250300001, 2026-09-08). Siblings failed the same
+way: FormEngineRemote 11/11, AutoFormField 1, SchemaDefinitionField 2,
+useWebsocket 3, TemplateField 1.
+
+## Root causes
+
+1. **An LSP connection outlived the story that opened it.** `useRenderExpression`
+   holds the endpoint's `LspSharedConnection` for the page lifetime. `Default`
+   (no mock LSP) dialled the real instance; `Empty` / `Text Mode` then joined that
+   connection's never-settling handshake, so their mock LSP was never dialled
+   ("Connecting to language server…" forever). Each passes when run alone.
+2. **The shared connection had no way out of a dead socket** (product bug). No
+   `onReconnectFailed` handling: a first handshake whose socket gave up stayed
+   pending forever for every later client; one that had completed kept reporting
+   the dead socket as ready. `close()` also abandoned an in-flight handshake, and
+   `release()` could evict a connection that had replaced its own after a reset.
+3. **Requests components make on their own were unmocked.** FormEngine gates on
+   `system/qorus-type-info`; TemplateField's "Use Expression" waits on the
+   expression catalogue; every `ReqraftWebSocket` reconnect awaits a `system/pid`
+   probe. Against an unreachable instance none settles — the form stays a
+   skeleton, the menu entry never appears, the socket never reconnects or gives
+   up. CI's live instance answered all three, which is why CI stayed green.
+4. **Mock URLs hard-coded the hq host.** Both mock layers match on host, so
+   overriding `REACT_APP_QORUS_INSTANCE` silently disabled every mock.
+
+## Fix
+
+- `src/utils/lspClient.ts` — give-up / close settle the handshake and forget the
+  socket; retry paths guarded by identity; `release()` only evicts itself.
+  4 new unit tests + the disconnect-mid-handshake test now asserts the rejection.
+- `src/stories/storyNetwork.ts` — `STORY_QORUS_INSTANCE`, `storyApiUrl`,
+  `storySocketUrl`, `GLOBAL_STORY_MOCK_DATA` (types catalogue, empty expression
+  catalogue, reconnect probe),
+  `TStoryMockResponse` (the addon silently ignores non-object responses).
+- `.storybook/preview.tsx` — `mockAddonConfigs.globalMockData`, per-story LSP
+  reset in a project `beforeEach`; `.storybook/vitest.setup.ts` mirrors the
+  addon's global + story merge.
+- All mock URLs moved to the helpers; FormEngine's duplicate types mock and
+  DpqlEditor's ad-hoc `closeAll()` removed.
+
+### Reconciled with `fix/per-field-templates`
+
+- That branch had already met the leak from the fixture side:
+  `createMockLspServer` reset the shared connections on create and close. The
+  project-level `beforeEach` covers the same ground plus stories that never
+  create a mock server (and the render client), so the fixture resets were
+  dropped in favour of the one mechanism.
+- Its `query()` strips a path's leading slash and uses a `noApiPrefix` url
+  verbatim; `buildReqraftApiUrl` follows those rules, so the doubled-slash mock
+  spellings are gone.
+- **A page-freezing render loop in the row menu** (from `a21640b`), reachable
+  only once FormEngine rendered offline: `FormEngine › Compact Expressions`
+  froze the tab and hung the whole suite with no output. The row kept ONE
+  `{key, items}` slot, and an expression's operands — separate TemplateFields
+  in the same row — published different keys into it, each overwrite
+  re-rendering the row and both operands. The same slot also kept an unmounted
+  editor's handlers when a reopened row offered the same key. Fixed in
+  `rowMenuContext.ts` (per-publisher registration via `useId`, withdrawn on
+  unmount, clicks delegated to the latest handler) and `TemplateField` (claims
+  the channel and hides it from what it renders, so operands keep their own
+  menu). Unit tests reproduce the loop and both stale-handler cases.
+- `ExpressionField › Field Menu Stays In The Toolbar` had gone stale on that
+  branch: `a21640b` moved a row field's menu into the row's ⋮ (one menu per
+  control) after the story was written. The story now asserts that single
+  menu — the row's `.options-readfirst-more`, with no `.template-more` beside
+  it — still sits level with the toolbar.
+
+## Not causes (checked)
+
+- "No Preview" in failure output: addon-vitest injects Storybook's hidden preview
+  body into every test page; a failed query's DOM dump prints it.
+- A `+` in the checkout path hangs `yarn test:stories` before any test runs
+  (mechanism not traced); unrelated to the stories.
+
+## Follow-ups (not done)
+
+- `users?action=current` is still unmocked for most stories — harmless today
+  (`waitForStorage={false}`), but CI renders a real user while local runs render
+  none. Candidate for a default mock once permission-gated snapshots are checked.
+- Unmocked requests still pass through to the network. Failing them loudly for
+  non-live stories would make this class impossible rather than documented.
+- `ReqraftWebSocketsManager.closeAll()` deletes entries by `socket.url` rather than
+  the pool key, and closing a CONNECTING socket reports code 1006, which schedules
+  a reconnect. Not exercised by this fix.
+- ~~`tests.yml` runs only on `pull_request`~~ — done on this branch: it now also
+  runs on pushes to `develop` (the push trigger had been dropped in 2021 with no
+  recorded reason). Conflicting PRs still get no `pull_request` runs until they
+  merge up.

package/README.md

@@ -148,7 +148,7 @@ client.onNotification('qonsole/sessionStateChanged', (params) => { /* … */ });
 client.disconnect();
 ```
 
-Clients on the same LSP endpoint share ONE underlying WebSocket — each `ReqraftLspClient` is a per-document facade over the shared connection, multiplexed by document URI (the server keys language sessions per document), so N editors cost one socket. Auto-reconnect re-opens every document on the shared socket, 15s request timeout, request/response correlation by `id`, pending requests rejected on close. Document URIs should be opaque and client-generated — per the Qonsole LSP contract they must not contain session tokens, usernames, sandbox identifiers, or other secrets that end up in server logs.
+Clients on the same LSP endpoint share ONE underlying WebSocket — each `ReqraftLspClient` is a per-document facade over the shared connection, multiplexed by document URI (the server keys language sessions per document), so N editors cost one socket. Auto-reconnect re-opens every document on the shared socket, 15s request timeout, request/response correlation by `id`, pending requests rejected on close. A `connect()` never outlives its socket: once the socket exhausts `maxReconnectTries`, a handshake still waiting rejects, and the next `connect()` — from that client or any other — dials again, so an editor opened after an outage connects once the server is back, without a page reload. Document URIs should be opaque and client-generated — per the Qonsole LSP contract they must not contain session tokens, usernames, sandbox identifiers, or other secrets that end up in server logs.
 
 ## Community
 

package/design/FORM_ENGINE_EXPRESSIONS.md

@@ -124,6 +124,116 @@ templates/return-type, and bind a provider only when the field supplies
 one. Worst case, text mode still parses/serializes correctly with no
 provider; only completions are reduced.
 
+## Detecting an expression typed as plain text
+
+*Added 2026-09-06. As-built.*
+
+An author who never opens the expression view still types DPQL into the
+ordinary editor. `TemplateField` notices, and what it does next depends on
+the field's own type.
+
+**A successful parse means nothing.** This is the finding the whole design
+rests on, and it is counter-intuitive enough to be worth stating plainly.
+Verified against the live LSP: `dpql/parse` returns `success: true` for
+`hello`, for `42`, for `2026-09-06` and for `@a`. A bare literal is a valid
+DPQL program, so "does it parse?" cannot separate an expression from a
+value. What separates them is the shape of the AST that comes back:
+
+| typed text | `exp` | verdict |
+|---|---|---|
+| `hello`, `42`, `2026-09-06`, `@a` | `value` | a literal |
+| `$local:count` | `template` | a template |
+| `@a > 5`, `"a" + "b"`, `toInt("5")`, `@n LIKE "a%"` | `>`, `+`, `toInt`, `like` | an expression |
+
+Text that is not DPQL at all is safe on its own: `hello world`, `x@y.com`,
+`a - b test` and `{"a":1}` all fail to parse outright.
+
+**Three stages, in `helpers/dpqlDetection.ts`:**
+
+1. `mightBeDpqlExpression` — a cheap lexical pass whose ONLY job is to keep
+   a server round-trip off every keystroke. It decides nothing. `-` and `/`
+   require surrounding spaces so a date or a path never triggers a probe.
+2. `dpql/parse` on the shared probe document (below), debounced 400 ms.
+3. `classifyTypedText` — `switch` when the text could not be a literal of
+   the field's declared type (the form's own `validateField` answers that),
+   `offer` when it could, `none` otherwise.
+
+**Why the asymmetry.** Rewriting the string `a + b` into a concatenation on
+a `string` field would destroy a value the author meant, so a type that
+accepts any text is only ever OFFERED the switch. Text that could not be a
+literal there was already an error the moment it was typed, so switching
+costs nothing and explains the error. Every switch carries an Undo that
+restores the exact text, and a declined text is never asked about again.
+
+**Reachability.** The auto-switch only applies where the editor accepts free
+text — a constrained `string` (identifier / `validation_regex`), `binary`,
+`hash`. `int` and `float` render `input[type=number]`, which drops `@`, `>`
+and spaces before any handler runs, so detection there is unreachable by
+design of the editor and the ⋮ menu remains the way in. Pinned by a test.
+
+**Template precedence.** `isValueTemplate` is deliberately loose (starts
+with `$`, contains `:`), so `$local:count + 1` was being swallowed into
+template mode with its arithmetic as dead text. A value that is not one
+complete template token and carries an operator now stays in the plain
+editor, where detection can reach it. A token standing alone
+(`$local:count`, `$data:{1.field}`) still flips, unchanged.
+
+**The probe document** (`components/dpqlEditor/dpqlProbe.ts`). One shared,
+lazily-opened DPQL document for the whole app, reference-counted by
+`useDpqlProbe` and closed when the last field using it unmounts. It is
+cheap: `ReqraftLspClient` multiplexes every document over ONE socket per
+endpoint and `initialize` runs once for it, so a probe is one extra
+`didOpen` plus one server-side session — not a connection. It is still
+shared rather than per-field, because a form with forty expression-capable
+options would otherwise open forty sessions to ask the same question.
+
+The document binds NO provider context; verified live, a context-less
+`didOpen` still builds a session that `dpql/parse` answers on. It sends no
+`target_type` either: detection asks whether the text is an expression, not
+whether it is the right type — a mismatch is something to show the author
+inside the editor, never a reason to refuse to open it. A probe never
+throws; an unreachable instance simply leaves the typed text alone.
+
+## Return-type checking
+
+*Added 2026-09-06. As-built.*
+
+`dpql/parse` has always been able to answer "can this expression's result
+satisfy type X?" — it takes a `target_type` and returns `inferred_type`,
+`type_compatible`, `auto_coercible` and a `suggested_fix`. Nothing in the
+front end ever sent one, so it never answered.
+
+`ExpressionField` now sends the field's own type with every parse, and
+shows what comes back. Three outcomes, not two:
+
+| the expression | shown |
+|---|---|
+| already fits | nothing |
+| converts, and the conversion is TOTAL (a number used as text) | nothing |
+| converts, but the conversion may FAIL (text used as a number) | a warning, with the conversion offered |
+| cannot convert at all | a danger message, with the conversion offered |
+
+The middle row is why the server grew `coercion_may_fail`: `canAutoCoerce()`
+admits both kinds, and reporting a conversion that cannot fail is what
+teaches authors to ignore the reports that matter.
+
+`auto` and `any` are never sent as a target — they accept anything, so the
+answer would always be "compatible" and the round trip would buy nothing. A
+field offering a CHOICE of return types sends nothing either, rather than
+asking about one of them arbitrarily.
+
+**What the field cannot decide.** Whether text really denotes a number
+depends on the text, which does not exist until the expression runs. So the
+warning is a warning, not a refusal, and the value is checked again
+server-side at run time — see `design/test-interface-object.md` in the qorus
+repo. For that to be possible the FormEngine's stored envelope carries the
+field's `type` beside `is_expression` and the AST, which is the type the
+author was shown.
+
+The same analysis lives in two server handlers (the LSP's `dpql/parse` and
+the Creator WS equivalent); both were changed together. Deduplicating them
+is a separate cleanup.
+
 ## Out of scope
 
 - `server_expression_handling` server-function-vs-qorus-function

package/design/RENDER_EXPRESSION_TRANSPORT.md

@@ -88,3 +88,21 @@ errors: -32602 missing/invalid expression; -32803 render failure;
   and `serverRendering` reports `false`.
 - Consumers (`builder/renderTemplate.tsx`, `ExpressionField.tsx`) are
   untouched.
+
+## Lifetime of the shared render socket
+
+The module-level render client never releases its connection: the first
+expression rendered on a page holds the endpoint's `LspSharedConnection` for
+the rest of the page. Two consequences are designed for:
+
+- **A socket that gives up is forgotten.** When the socket exhausts its
+  reconnect attempts, the connection fails any handshake still waiting and
+  drops the socket; the next `connect()` from any client on that endpoint
+  dials afresh. Without this, a first handshake that never completed held
+  every later editor on "Connecting to language server…" for the life of the
+  page, and one that had completed kept reporting the dead socket as ready.
+- **Storybook resets it per story.** Stories run in one page, so the
+  connection an earlier story opened would otherwise serve a later story —
+  including one that starts its own mock LSP, which is then never dialled.
+  `.storybook/preview.tsx` runs `_resetRenderExpressionTransportForTests()`
+  and `_resetSharedLspConnectionsForTests()` in a project-level `beforeEach`.

package/dist/components/dpqlEditor/dpqlProbe.d.ts

@@ -0,0 +1,37 @@
+/** What a probe answers. Never throws — a failure is `success: false`. */
+export interface IDpqlProbeResult {
+    success: boolean;
+    expression: Record<string, any> | null;
+    diagnostics: Array<{
+        severity?: number | string;
+        message?: string;
+        code?: string | number;
+    }>;
+}
+declare class DpqlProbe {
+    private client;
+    private opened;
+    private users;
+    private readonly cache;
+    /** Register a consumer; the document is still not opened until it probes. */
+    acquire(): void;
+    /** Drop a consumer, closing the shared document when the last one goes. */
+    release(): void;
+    /**
+     * Parse `text` on the shared probe document. Resolves to `FAILED` rather
+     * than rejecting, for any reason at all — a field must never break because
+     * the instance is unreachable.
+     */
+    parse(text: string): Promise<IDpqlProbeResult>;
+    /** Open (once) and return the shared document's client. */
+    private open;
+    private remember;
+    private close;
+}
+/**
+ * The process-wide probe. Exported for tests, which reset it between cases;
+ * application code goes through `useDpqlProbe`.
+ */
+export declare const dpqlProbe: DpqlProbe;
+export {};
+//# sourceMappingURL=dpqlProbe.d.ts.map

package/dist/components/dpqlEditor/dpqlProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dpqlProbe.d.ts","sourceRoot":"","sources":["../../../src/components/dpqlEditor/dpqlProbe.ts"],"names":[],"mappings":"AAgCA,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IACvC,WAAW,EAAE,KAAK,CAAC;QAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9F;AAaD,cAAM,SAAS;IACb,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAE7D,6EAA6E;IAC7E,OAAO,IAAI,IAAI;IAIf,2EAA2E;IAC3E,OAAO,IAAI,IAAI;IAQf;;;;OAIG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgCpD,2DAA2D;IAC3D,OAAO,CAAC,IAAI;IAyBZ,OAAO,CAAC,QAAQ;IAYhB,OAAO,CAAC,KAAK;CAad;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,WAAkB,CAAC"}

package/dist/components/dpqlEditor/dpqlProbe.js

@@ -0,0 +1,203 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dpqlProbe = void 0;
+// Copyright 2026 Qore Technologies, s.r.o.
+/**
+ * One shared, lazily-opened DPQL document used to ask the server "is this
+ * text really an expression?" on behalf of plain form fields that have no
+ * editor of their own.
+ *
+ * ## Why a singleton, and why it is cheap
+ *
+ * `ReqraftLspClient` multiplexes every document over ONE socket per endpoint
+ * (`LspSharedConnection`), and `initialize` runs once for that socket. A
+ * probe is therefore not a new connection — it is one extra `didOpen`, and
+ * one `QorusDpqlActionSession` in the server's `uriToDpqlSession` map. Even
+ * so it is a single shared document rather than one per field: a form with
+ * forty expression-capable options would otherwise open forty of them to ask
+ * the same question.
+ *
+ * Nothing is opened until a field actually probes, so a form whose author
+ * never types anything expression-shaped costs nothing at all.
+ *
+ * The document is opened with NO provider context. Verified against the live
+ * server: `textDocument/didOpen` with `languageId: 'dpql'` and no metadata
+ * still builds a session, and `dpql/parse` answers on it. Record-field
+ * references (`@name`) do not resolve to a provider's fields without that
+ * context, which is fine — detection asks about the SHAPE of the expression,
+ * and the editor the author lands in binds the real context.
+ *
+ * No `target_type` is sent. Detection asks "is this an expression", not "is
+ * it the right type"; a type mismatch is a thing to show the author INSIDE
+ * the expression editor, not a reason to refuse to open it.
+ */
+var lspClient_1 = require("../../utils/lspClient");
+var FAILED = { success: false, expression: null, diagnostics: [] };
+/** Opaque, non-secret document URI — the server keys its session by this. */
+var PROBE_URI = 'dpql://probe/detection';
+/**
+ * How many parsed texts to remember. Typing walks through many prefixes of
+ * the same expression, and an author re-typing a value should not re-ask.
+ */
+var MAX_CACHE_ENTRIES = 200;
+var DpqlProbe = /** @class */ (function () {
+    function DpqlProbe() {
+        this.client = null;
+        this.opened = null;
+        this.users = 0;
+        this.cache = new Map();
+    }
+    /** Register a consumer; the document is still not opened until it probes. */
+    DpqlProbe.prototype.acquire = function () {
+        this.users += 1;
+    };
+    /** Drop a consumer, closing the shared document when the last one goes. */
+    DpqlProbe.prototype.release = function () {
+        this.users = Math.max(0, this.users - 1);
+        if (this.users === 0) {
+            this.close();
+        }
+    };
+    /**
+     * Parse `text` on the shared probe document. Resolves to `FAILED` rather
+     * than rejecting, for any reason at all — a field must never break because
+     * the instance is unreachable.
+     */
+    DpqlProbe.prototype.parse = function (text) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cached, result, client, response, _a;
+            var _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        cached = this.cache.get(text);
+                        if (cached) {
+                            return [2 /*return*/, cached];
+                        }
+                        result = FAILED;
+                        _e.label = 1;
+                    case 1:
+                        _e.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, this.open()];
+                    case 2:
+                        client = _e.sent();
+                        return [4 /*yield*/, client.customRequest('dpql/parse', {
+                                uri: PROBE_URI,
+                                text: text,
+                            })];
+                    case 3:
+                        response = _e.sent();
+                        result = {
+                            success: (_b = response === null || response === void 0 ? void 0 : response.success) !== null && _b !== void 0 ? _b : false,
+                            expression: (_c = response === null || response === void 0 ? void 0 : response.expression) !== null && _c !== void 0 ? _c : null,
+                            diagnostics: (_d = response === null || response === void 0 ? void 0 : response.diagnostics) !== null && _d !== void 0 ? _d : [],
+                        };
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _a = _e.sent();
+                        // Unreachable instance, closed socket, request timeout: the field
+                        // simply learns nothing and leaves the typed text exactly as it is.
+                        result = FAILED;
+                        return [3 /*break*/, 5];
+                    case 5:
+                        this.remember(text, result);
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /** Open (once) and return the shared document's client. */
+    DpqlProbe.prototype.open = function () {
+        var _this = this;
+        if (this.opened) {
+            return this.opened;
+        }
+        this.opened = (function () { return __awaiter(_this, void 0, void 0, function () {
+            var client;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        client = new lspClient_1.ReqraftLspClient({ languageId: 'dpql', uri: PROBE_URI });
+                        return [4 /*yield*/, client.connect()];
+                    case 1:
+                        _a.sent();
+                        // `didOpen` is a notification on the same socket as the request that
+                        // follows it, so the server has the session by the time the parse
+                        // arrives — no readiness poll needed.
+                        client.didOpen('');
+                        this.client = client;
+                        return [2 /*return*/, client];
+                }
+            });
+        }); })().catch(function (error) {
+            // Allow a later probe to retry a connection that failed once.
+            _this.opened = null;
+            throw error;
+        });
+        return this.opened;
+    };
+    DpqlProbe.prototype.remember = function (text, result) {
+        if (this.cache.size >= MAX_CACHE_ENTRIES) {
+            var oldest = this.cache.keys().next();
+            if (!oldest.done) {
+                this.cache.delete(oldest.value);
+            }
+        }
+        this.cache.set(text, result);
+    };
+    DpqlProbe.prototype.close = function () {
+        var client = this.client;
+        this.client = null;
+        this.opened = null;
+        this.cache.clear();
+        try {
+            client === null || client === void 0 ? void 0 : client.disconnect();
+        }
+        catch (_a) {
+            // best-effort teardown
+        }
+    };
+    return DpqlProbe;
+}());
+/**
+ * The process-wide probe. Exported for tests, which reset it between cases;
+ * application code goes through `useDpqlProbe`.
+ */
+exports.dpqlProbe = new DpqlProbe();
+//# sourceMappingURL=dpqlProbe.js.map

package/dist/components/dpqlEditor/dpqlProbe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dpqlProbe.js","sourceRoot":"","sources":["../../../src/components/dpqlEditor/dpqlProbe.ts"],"names":[],"mappings":"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"}

package/dist/components/dpqlEditor/index.d.ts

@@ -1,5 +1,9 @@
 export { DpqlEditor } from './DpqlEditor';
 export type { IDpqlEditorProps, IDpqlEditorRef, IDpqlParseResult, ISlateElement, ISlateText, TSlateNode, } from './types';
+export { dpqlProbe } from './dpqlProbe';
+export type { IDpqlProbeResult } from './dpqlProbe';
+export { useDpqlProbe } from './useDpqlProbe';
+export type { TDpqlProbeFn } from './useDpqlProbe';
 export { useDpqlSession } from './useDpqlSession';
 export type { IDpqlFieldMeta, IUseDpqlSessionOptions, IUseDpqlSessionResult, } from './useDpqlSession';
 export { dpqlSlateConverter, getTagLabel, isTagCompletion, plainTextToSlate, slateSelectionToOffset, slateToPlainText, } from './dpqlHelpers';

package/dist/components/dpqlEditor/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/dpqlEditor/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EACV,cAAc,EACd,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,eAAe,EACf,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/dpqlEditor/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EACV,cAAc,EACd,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAI1B,OAAO,EACL,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,sBAAsB,EACtB,eAAe,EACf,eAAe,EACf,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/components/dpqlEditor/index.js

@@ -2,9 +2,13 @@
 // Copyright 2026 Qore Technologies, s.r.o.
 // Public surface of the DpqlEditor component.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dpqlCompletionInserter = exports.makeDpqlTagRenderer = exports.TEMPLATE_COLORS = exports.FIELD_REF_COLOR = exports.DEFAULT_TEMPLATE_COLOR = exports.slateToPlainText = exports.slateSelectionToOffset = exports.plainTextToSlate = exports.isTagCompletion = exports.getTagLabel = exports.dpqlSlateConverter = exports.useDpqlSession = exports.DpqlEditor = void 0;
+exports.dpqlCompletionInserter = exports.makeDpqlTagRenderer = exports.TEMPLATE_COLORS = exports.FIELD_REF_COLOR = exports.DEFAULT_TEMPLATE_COLOR = exports.slateToPlainText = exports.slateSelectionToOffset = exports.plainTextToSlate = exports.isTagCompletion = exports.getTagLabel = exports.dpqlSlateConverter = exports.useDpqlSession = exports.useDpqlProbe = exports.dpqlProbe = exports.DpqlEditor = void 0;
 var DpqlEditor_1 = require("./DpqlEditor");
 Object.defineProperty(exports, "DpqlEditor", { enumerable: true, get: function () { return DpqlEditor_1.DpqlEditor; } });
+var dpqlProbe_1 = require("./dpqlProbe");
+Object.defineProperty(exports, "dpqlProbe", { enumerable: true, get: function () { return dpqlProbe_1.dpqlProbe; } });
+var useDpqlProbe_1 = require("./useDpqlProbe");
+Object.defineProperty(exports, "useDpqlProbe", { enumerable: true, get: function () { return useDpqlProbe_1.useDpqlProbe; } });
 var useDpqlSession_1 = require("./useDpqlSession");
 Object.defineProperty(exports, "useDpqlSession", { enumerable: true, get: function () { return useDpqlSession_1.useDpqlSession; } });
 // `useDpqlSyntaxHighlighting` removed in 0.10.0 — syntax highlighting

package/dist/components/dpqlEditor/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/components/dpqlEditor/index.ts"],"names":[],"mappings":";AAAA,2CAA2C;AAC3C,8CAA8C;;;AAE9C,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AASnB,mDAAkD;AAAzC,gHAAA,cAAc,OAAA;AAMvB,sEAAsE;AACtE,mEAAmE;AACnE,oCAAoC;AACpC,6CAOuB;AANrB,iHAAA,kBAAkB,OAAA;AAClB,0GAAA,WAAW,OAAA;AACX,8GAAA,eAAe,OAAA;AACf,+GAAA,gBAAgB,OAAA;AAChB,qHAAA,sBAAsB,OAAA;AACtB,+GAAA,gBAAgB,OAAA;AAElB,uCAKoB;AAJlB,kHAAA,sBAAsB,OAAA;AACtB,2GAAA,eAAe,OAAA;AACf,2GAAA,eAAe,OAAA;AACf,+GAAA,mBAAmB,OAAA;AAErB,+CAAwD;AAA/C,sHAAA,sBAAsB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/components/dpqlEditor/index.ts"],"names":[],"mappings":";AAAA,2CAA2C;AAC3C,8CAA8C;;;AAE9C,2CAA0C;AAAjC,wGAAA,UAAU,OAAA;AASnB,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAElB,+CAA8C;AAArC,4GAAA,YAAY,OAAA;AAErB,mDAAkD;AAAzC,gHAAA,cAAc,OAAA;AAMvB,sEAAsE;AACtE,mEAAmE;AACnE,oCAAoC;AACpC,6CAOuB;AANrB,iHAAA,kBAAkB,OAAA;AAClB,0GAAA,WAAW,OAAA;AACX,8GAAA,eAAe,OAAA;AACf,+GAAA,gBAAgB,OAAA;AAChB,qHAAA,sBAAsB,OAAA;AACtB,+GAAA,gBAAgB,OAAA;AAElB,uCAKoB;AAJlB,kHAAA,sBAAsB,OAAA;AACtB,2GAAA,eAAe,OAAA;AACf,2GAAA,eAAe,OAAA;AACf,+GAAA,mBAAmB,OAAA;AAErB,+CAAwD;AAA/C,sHAAA,sBAAsB,OAAA"}