@omgbase/core 0.1.0

package/dist/src/mutate/opset.js

@@ -0,0 +1,79 @@
+/** The bare kernel ops, in order — what `apply` actually replays. */
+export function opsetKernelOps(opset) {
+    return opset.ops.map((p) => p.op);
+}
+/** Compute the summary from the planned ops + carried/ambiguous counts. */
+export function summarizeOps(ops, counts) {
+    const s = {
+        preserved: counts.preserved,
+        updated: 0, moved: 0, created: 0, removed: 0, split: 0, merged: 0,
+        ambiguous: counts.ambiguous,
+    };
+    for (const p of ops) {
+        switch (p.disposition) {
+            case "edited":
+                s.updated++;
+                break;
+            case "moved":
+                s.moved++;
+                break;
+            case "edited_moved":
+                s.updated++;
+                s.moved++;
+                break;
+            case "inserted":
+            case "copied_from":
+            case "resurrected":
+                s.created++;
+                break;
+            case "deleted":
+                s.removed++;
+                break;
+            case "split_from":
+                s.split++;
+                break;
+            case "merged_into":
+                s.merged++;
+                break;
+            // "retiled"/"same"/"bulk_rewrite" carry no summary bucket of their own.
+        }
+    }
+    return s;
+}
+/** Serialize an opset to a stable JSON string (ops are plain JSON). */
+export function serializeOpset(opset) {
+    return JSON.stringify(opset);
+}
+/** Parse a serialized opset, validating the version tag. */
+export function parseOpset(text) {
+    const o = JSON.parse(text);
+    if (o.version !== 1 || o.kind !== "doc_update") {
+        throw new Error(`unrecognized opset (version ${String(o.version)})`);
+    }
+    return o;
+}
+// A short human-/agent-readable rendering that makes identity consequences
+// obvious (04-mutation §, the note's example). One line per op + a summary.
+const VERB = {
+    same: "KEEP  ", edited: "UPDATE", moved: "MOVE  ", edited_moved: "UPDATE",
+    inserted: "INSERT", deleted: "REMOVE", split_from: "SPLIT ", merged_into: "MERGE ",
+    copied_from: "COPY  ", resurrected: "RESURR", bulk_rewrite: "REWRITE", retiled: "RETILE",
+};
+export function renderOpsetPlan(opset) {
+    const lines = [];
+    for (const p of opset.ops) {
+        const subject = p.blocks[0] ?? "(new)";
+        const conf = p.confidence !== null ? ` ~${p.confidence.toFixed(2)}` : "";
+        const why = p.reason ? ` [${p.reason}]` : "";
+        lines.push(`${VERB[p.disposition]} ${subject.padEnd(9)} ${p.disposition}${conf}${why}`);
+    }
+    const s = opset.summary;
+    lines.push("");
+    lines.push(`preserved: ${s.preserved}  updated: ${s.updated}  moved: ${s.moved}  ` +
+        `created: ${s.created}  removed: ${s.removed}  split: ${s.split}  ` +
+        `merged: ${s.merged}  ambiguous: ${s.ambiguous}`);
+    if (!opset.converges)
+        lines.push(`WARNING: plan does not reproduce the proposed content exactly — will not apply.`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=opset.js.map

package/dist/src/mutate/plan-update.d.ts

@@ -0,0 +1,51 @@
+import type { Store } from "../core/store/store.js";
+import { type ReconcileConfig } from "../reconcile/types.js";
+import { type ApplyResult } from "./apply.js";
+import { type Opset } from "./opset.js";
+export interface PlanUpdateOptions {
+    config?: ReconcileConfig;
+}
+/**
+ * Plan a whole-document update. `docRef` is a doc id or repo-relative path;
+ * `content` is the proposed complete document. Throws doc_missing if the
+ * document does not exist (a create is docsCreate's job). Never writes.
+ */
+export declare function planUpdate(store: Store, repoId: string, rootPath: string, docRef: string, content: string, opts?: PlanUpdateOptions): Opset;
+export interface ApplyOpsetRequest {
+    repoId: string;
+    rootPath: string;
+    opset: Opset;
+    origin: {
+        actor: string;
+        reason?: string;
+    };
+    dryRun?: boolean;
+    omgbaseDir?: string;
+}
+/**
+ * Apply an opset through the kernel write path. Validates the plan's
+ * preconditions against current state first (a stale plan fails, carrying
+ * current truth, rather than silently reinterpreting) and refuses a plan that
+ * did not verify byte-convergent.
+ */
+export declare function applyOpset(store: Store, req: ApplyOpsetRequest): ApplyResult;
+export interface DocsUpdateContext {
+    repoId: string;
+    rootPath: string;
+    omgbaseDir?: string;
+    actor?: string;
+}
+export interface DocsUpdateResult {
+    opset: Opset;
+    /** null on dry_run (plan only) */
+    result: ApplyResult | null;
+}
+/**
+ * Whole-document update convenience: plan then apply. `dryRun` returns the
+ * opset without executing (the note's docs.update(..., dry_run=true)).
+ */
+export declare function docsUpdate(store: Store, ctx: DocsUpdateContext, docRef: string, content: string, opts?: {
+    dryRun?: boolean;
+    config?: ReconcileConfig;
+    reason?: string;
+}): DocsUpdateResult;

package/dist/src/mutate/plan-update.js

@@ -0,0 +1,187 @@
+import { sha256 } from "../core/hash.js";
+import { parseTree } from "../core/parse/tree.js";
+import { adapterForPath } from "../format/index.js";
+import { findDocByRef } from "../core/read/reader.js";
+import { reconcileDocument } from "../reconcile/reconcile.js";
+import { flatten } from "../reconcile/flatten.js";
+import { DEFAULT_CONFIG } from "../reconcile/types.js";
+import { loadOldMatchBlocks } from "../sync/reconciling-ingest.js";
+import { loadMutDoc } from "./load.js";
+import { renderDoc, MutationError } from "./tree.js";
+import { apply } from "./apply.js";
+import { lowerTopLevel, lowerReplace } from "./lower.js";
+import { summarizeOps, opsetKernelOps } from "./opset.js";
+function toFlatSource(b) {
+    return { type: b.type, raw: b.raw, children: b.children.map(toFlatSource) };
+}
+function extractFrontmatter(blocks) {
+    if (blocks.length > 0 && blocks[0].type === "frontmatter")
+        return { fmBlock: blocks[0], rest: blocks.slice(1) };
+    return { fmBlock: null, rest: blocks };
+}
+/**
+ * Plan a whole-document update. `docRef` is a doc id or repo-relative path;
+ * `content` is the proposed complete document. Throws doc_missing if the
+ * document does not exist (a create is docsCreate's job). Never writes.
+ */
+export function planUpdate(store, repoId, rootPath, docRef, content, opts = {}) {
+    const config = opts.config ?? DEFAULT_CONFIG;
+    const info = findDocByRef(store, repoId, docRef);
+    if (!info)
+        throw new MutationError("doc_missing", `doc ${docRef} not found`, { doc: docRef });
+    const docId = info.docId;
+    const path = info.path;
+    const oldDoc = loadMutDoc(store.db, docId);
+    if (!oldDoc)
+        throw new MutationError("doc_missing", `doc ${docRef} not found`, { doc: docRef });
+    // Base state the plan is pinned to. baseContentHash is the current rendered
+    // bytes (== docs.file_hash at quiescence); a stale plan is rejected at apply.
+    const currentContent = renderDoc(oldDoc);
+    const baseContentHash = sha256(currentContent).toString("hex");
+    // Parse the proposed content with the doc's format adapter.
+    const adapter = adapterForPath(path);
+    const tree = adapter ? adapter.parse(content) : parseTree(content);
+    const { fmBlock, rest } = extractFrontmatter(tree.children);
+    // Reconcile the proposed body against the current tree (no resurrection pool:
+    // the op path mints new ids for new structure rather than reusing tombstones).
+    const oldMatch = loadOldMatchBlocks(store.db, docId);
+    const newMatch = flatten(rest.map(toFlatSource));
+    const result = reconcileDocument(oldMatch, newMatch, { config });
+    // Frontmatter is a document-level unit outside the six block ops. loadMutDoc
+    // builds frontmatterRaw as `bytes + separator`; mirror that for the target.
+    const targetFm = fmBlock ? fmBlock.raw + fmBlock.trivia : null;
+    const fmChanged = targetFm !== oldDoc.frontmatterRaw;
+    const setFrontmatter = fmChanged ? [{ doc: docId, raw: targetFm }] : undefined;
+    const diagnostics = [];
+    // Try lowerings in order of decreasing identity preservation; take the first
+    // that reproduces the proposed content exactly.
+    let chosen = null;
+    let converges = false;
+    const t2 = lowerTopLevel(oldDoc, rest, assignmentOf(result), dispositionsOf(result));
+    const v2 = verify(store, repoId, rootPath, path, opsOf(t2), setFrontmatter, content, currentContent);
+    if (v2.ok) {
+        chosen = t2;
+        converges = true;
+    }
+    else {
+        diagnostics.push(`top-level lowering did not reproduce the proposed content byte-for-byte (${describeDivergence(v2, tree.children, content)}); falling back to full replace`);
+        const t3 = lowerReplace(oldDoc, content);
+        const v3 = verify(store, repoId, rootPath, path, opsOf(t3), setFrontmatter, content, currentContent);
+        if (v3.ok) {
+            chosen = t3;
+            converges = true;
+            diagnostics.push("full-replace plan converges (block identity not preserved)");
+        }
+        else {
+            // Neither converged: return the identity-preserving plan but flag it. apply
+            // refuses a non-convergent plan (loud failure), so no wrong bytes land.
+            chosen = t2;
+            diagnostics.push(`no lowering reproduced the proposed content exactly (full replace: ${describeDivergence(v3, tree.children, content)}); plan will not apply — inspect and re-plan`);
+        }
+    }
+    const ops = chosen.ops;
+    const summary = summarizeOps(ops, { preserved: chosen.preserved, ambiguous: chosen.ambiguous });
+    return {
+        version: 1,
+        kind: "doc_update",
+        target: { doc: docId, path },
+        precondition: { doc: docId, path, baseRevision: info.currentRev, baseContentHash },
+        matcherV: config.matcherV,
+        ops,
+        ...(fmChanged ? { frontmatter: { raw: targetFm } } : {}),
+        summary,
+        converges,
+        diagnostics,
+    };
+}
+function assignmentOf(r) { return r.assignment; }
+function dispositionsOf(r) {
+    return r.dispositions;
+}
+function opsOf(l) { return l.ops.map((p) => p.op); }
+// Simulate a candidate op list and check the rendered result equals the exact
+// proposed content. An invalid script throws in apply → treated as non-convergent.
+function verify(store, repoId, rootPath, path, ops, setFrontmatter, expected, currentContent) {
+    try {
+        const res = apply(store, { repoId, rootPath, ops, origin: { actor: "plan:verify" }, dryRun: true, ...(setFrontmatter ? { setFrontmatter } : {}) });
+        // A doc untouched by any op (e.g. an empty plan) is absent from diffs; its
+        // effective result is the unchanged current content.
+        const after = res.diffs?.[path]?.after ?? currentContent;
+        return after === expected ? { ok: true } : { ok: false, actual: after, error: null };
+    }
+    catch (e) {
+        return { ok: false, actual: null, error: e instanceof Error ? `${e.code ?? "error"}: ${e.message}` : String(e) };
+    }
+}
+// Name the failure precisely: the first differing byte offset and the proposed
+// top-level block (index + type) whose span covers it, so a caller learns WHICH
+// construct failed to round-trip rather than just "no lowering converged".
+function describeDivergence(v, proposed, expected) {
+    if (v.ok)
+        return "converged";
+    if (v.actual === null)
+        return `simulation threw ${v.error}`;
+    const actual = v.actual;
+    let off = 0;
+    const n = Math.min(actual.length, expected.length);
+    while (off < n && actual.charCodeAt(off) === expected.charCodeAt(off))
+        off++;
+    const idx = proposed.findIndex((b) => off >= b.span.start && off < b.span.end + b.trivia.length);
+    const where = idx >= 0 ? `proposed block #${idx} (${proposed[idx].type}, bytes ${proposed[idx].span.start}-${proposed[idx].span.end})` : off >= expected.length ? "past the end of the proposed content" : "leading trivia";
+    const snippet = (s) => JSON.stringify(s.slice(off, off + 24));
+    return `first divergence at byte ${off} in ${where}: expected ${snippet(expected)}, rendered ${snippet(actual)}`;
+}
+/**
+ * Apply an opset through the kernel write path. Validates the plan's
+ * preconditions against current state first (a stale plan fails, carrying
+ * current truth, rather than silently reinterpreting) and refuses a plan that
+ * did not verify byte-convergent.
+ */
+export function applyOpset(store, req) {
+    const { opset } = req;
+    if (!opset.converges) {
+        const why = opset.diagnostics.length > 0 ? ` — ${opset.diagnostics[opset.diagnostics.length - 1]}` : "";
+        throw new MutationError("plan_not_convergent", `opset does not reproduce the proposed content; re-plan${why}`, { diagnostics: opset.diagnostics });
+    }
+    // Precondition: the document must still be at the revision/content the plan
+    // was computed against.
+    const row = store.db.prepare("SELECT current_rev, lower(hex(file_hash)) fh FROM docs WHERE doc_id = ? AND deleted_commit IS NULL").get(opset.precondition.doc);
+    if (!row)
+        throw new MutationError("doc_missing", `doc ${opset.precondition.doc} not found`, { doc: opset.precondition.doc });
+    const stale = (opset.precondition.baseRevision !== null && row.current_rev !== opset.precondition.baseRevision) || (row.fh !== null && row.fh !== opset.precondition.baseContentHash);
+    if (stale) {
+        throw new MutationError("stale_plan", "document changed since the plan was computed; re-plan", {
+            doc: opset.precondition.doc,
+            expected_revision: opset.precondition.baseRevision,
+            current: { revision: row.current_rev, content_hash: row.fh },
+            retriable: true,
+        });
+    }
+    return apply(store, {
+        repoId: req.repoId,
+        rootPath: req.rootPath,
+        ops: opsetKernelOps(opset),
+        origin: req.origin,
+        ...(req.dryRun !== undefined ? { dryRun: req.dryRun } : {}),
+        ...(req.omgbaseDir !== undefined ? { omgbaseDir: req.omgbaseDir } : {}),
+        ...(opset.frontmatter ? { setFrontmatter: [{ doc: opset.precondition.doc, raw: opset.frontmatter.raw }] } : {}),
+    });
+}
+/**
+ * Whole-document update convenience: plan then apply. `dryRun` returns the
+ * opset without executing (the note's docs.update(..., dry_run=true)).
+ */
+export function docsUpdate(store, ctx, docRef, content, opts = {}) {
+    const opset = planUpdate(store, ctx.repoId, ctx.rootPath, docRef, content, opts.config ? { config: opts.config } : {});
+    if (opts.dryRun)
+        return { opset, result: null };
+    const result = applyOpset(store, {
+        repoId: ctx.repoId,
+        rootPath: ctx.rootPath,
+        opset,
+        origin: { actor: ctx.actor ?? "agent:update", ...(opts.reason !== undefined ? { reason: opts.reason } : {}) },
+        ...(ctx.omgbaseDir !== undefined ? { omgbaseDir: ctx.omgbaseDir } : {}),
+    });
+    return { opset, result };
+}
+//# sourceMappingURL=plan-update.js.map

package/dist/src/mutate/tree.d.ts

@@ -0,0 +1,46 @@
+export interface MutBlock {
+    id: string;
+    type: string;
+    raw: string;
+    trivia: string;
+    attrs: Record<string, unknown>;
+    children: MutBlock[];
+    /** true if raw was supplied by an op (serialize as-is; 03 §2.2) */
+    dirty?: boolean;
+}
+export interface MutDoc {
+    docId: string;
+    path: string;
+    format: string;
+    leadingTrivia: string;
+    frontmatterRaw: string | null;
+    children: MutBlock[];
+}
+export declare class MutationError extends Error {
+    code: string;
+    data: Record<string, unknown>;
+    constructor(code: string, message: string, data?: Record<string, unknown>);
+}
+/** Find a block by id anywhere in the doc; returns the block + its parent list. */
+export declare function locate(doc: MutDoc, blockId: string): {
+    block: MutBlock;
+    siblings: MutBlock[];
+    index: number;
+} | null;
+export declare function rawHashHex(raw: string): string;
+/** The block that owns `children` (by reference identity), or null at top level. */
+export declare function ownerOf(doc: MutDoc, children: MutBlock[]): MutBlock | null;
+/**
+ * A container's raw is the authoritative render source (03 §2.2), so a
+ * structural change to its children (insert/remove/move) must invalidate the
+ * container's cached raw. Mark the owning container dirty so renderBlock
+ * reconstructs it from the mutated children rather than emitting the now-stale
+ * raw verbatim; ancestors see it via hasDirtyDescendant and reconstruct in turn.
+ * Top-level siblings (doc.children) need no marking — renderDoc renders each
+ * top-level block directly.
+ */
+export declare function markContainerDirty(doc: MutDoc, children: MutBlock[]): void;
+export declare function renderDoc(doc: MutDoc): string;
+/** Ordered ids of a parent's direct children (for parent_children_hash CAS). */
+export declare function childIds(list: MutBlock[]): string[];
+export declare function parentChildrenHash(list: MutBlock[]): string;

package/dist/src/mutate/tree.js

@@ -0,0 +1,167 @@
+import { sha256 } from "../core/hash.js";
+export class MutationError extends Error {
+    code;
+    data;
+    constructor(code, message, data = {}) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+/** Find a block by id anywhere in the doc; returns the block + its parent list. */
+export function locate(doc, blockId) {
+    const search = (list) => {
+        for (let i = 0; i < list.length; i++) {
+            const b = list[i];
+            if (b.id === blockId)
+                return { block: b, siblings: list, index: i };
+            const found = search(b.children);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    return search(doc.children);
+}
+export function rawHashHex(raw) {
+    return sha256(raw).toString("hex");
+}
+/** The block that owns `children` (by reference identity), or null at top level. */
+export function ownerOf(doc, children) {
+    if (children === doc.children)
+        return null;
+    let found = null;
+    const walk = (list) => {
+        for (const b of list) {
+            if (b.children === children) {
+                found = b;
+                return;
+            }
+            walk(b.children);
+        }
+    };
+    walk(doc.children);
+    return found;
+}
+/**
+ * A container's raw is the authoritative render source (03 §2.2), so a
+ * structural change to its children (insert/remove/move) must invalidate the
+ * container's cached raw. Mark the owning container dirty so renderBlock
+ * reconstructs it from the mutated children rather than emitting the now-stale
+ * raw verbatim; ancestors see it via hasDirtyDescendant and reconstruct in turn.
+ * Top-level siblings (doc.children) need no marking — renderDoc renders each
+ * top-level block directly.
+ */
+export function markContainerDirty(doc, children) {
+    const owner = ownerOf(doc, children);
+    if (owner)
+        owner.dirty = true;
+}
+// Render the doc by splice (03 §2.2): leading trivia, optional frontmatter, then
+// each top-level block + trivia. A block whose subtree contains no dirty node
+// emits its retained raw verbatim. When a descendant is dirty, the block is
+// re-rendered from its children (indented to their container) so nested edits
+// — e.g. a task checkbox toggle inside a list — surface without disturbing
+// untouched siblings.
+export function renderDoc(doc) {
+    const out = [doc.leadingTrivia];
+    if (doc.frontmatterRaw !== null)
+        out.push(doc.frontmatterRaw);
+    for (const b of doc.children) {
+        out.push(renderBlock(b, 0));
+        out.push(b.trivia);
+    }
+    return out.join("");
+}
+function hasDirtyDescendant(b) {
+    if (b.dirty)
+        return true;
+    return b.children.some(hasDirtyDescendant);
+}
+// Render one block. Leaf or fully-clean subtree ⇒ retained raw. Otherwise
+// reconstruct from children (a container with a dirty descendant).
+function renderBlock(b, depth) {
+    if (b.children.length === 0 || !hasDirtyDescendant(b))
+        return b.raw;
+    // A list is reconstructed from its items: each item's raw already carries its
+    // own marker + nested content (correctly indented), so we re-mark (ordered
+    // lists renumber after a reorder/insert) and join with the list's own
+    // tight/loose separator. This matches the canonical renderer, which treats a
+    // top-level block's raw as the authoritative source for its whole subtree.
+    if (b.type === "list")
+        return renderList(b);
+    // A blockquote's `> ` markers live only in the container raw, so a rebuild
+    // must re-prefix every line of every child (blank separator lines become a
+    // bare `>`), or the quote silently degrades to plain paragraphs.
+    if (b.type === "blockquote")
+        return renderBlockquote(b, depth);
+    // A table's delimiter row (`| --- | --- |`) is not a child node (mdast keeps
+    // only header/body rows), so re-insert the retained delimiter line after the
+    // header row when rebuilding from rows.
+    if (b.type === "table")
+        return renderTable(b, depth);
+    // Other containers (a list_item outside a list): fall back to the
+    // child-indent rebuild. Lists are the common mutable container.
+    const indent = "  ".repeat(depth);
+    return b.children.map((c) => indent + renderBlock(c, depth + 1).replace(/\n/g, "\n" + indent)).join("\n");
+}
+function renderBlockquote(bq, depth) {
+    const body = bq.children.map((c) => renderBlock(c, depth + 1)).join("\n\n");
+    return body.split("\n").map((ln) => (ln.length ? `> ${ln}` : ">")).join("\n");
+}
+function renderTable(t, depth) {
+    const rows = t.children.map((c) => renderBlock(c, depth + 1));
+    const lines = t.raw.split("\n");
+    const delimiter = lines.length >= 2 && /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)*\|?\s*$/.test(lines[1]) ? lines[1] : null;
+    if (delimiter !== null && rows.length >= 1)
+        rows.splice(1, 0, delimiter);
+    return rows.join("\n");
+}
+const MARKER_RE = /^(\s*)([-*+]|\d+[.)])(\s+)/;
+// Reconstruct a markdown list from its (possibly reordered / edited / added /
+// removed) items. Item raws are self-contained (marker + text + nested); we
+// only re-derive the leading marker so an ordered list renumbers correctly.
+function renderList(list) {
+    const ordered = Boolean(list.attrs.ordered);
+    const start = typeof list.attrs.start === "number" ? list.attrs.start : 1;
+    const sep = list.raw.includes("\n\n") ? "\n\n" : "\n";
+    return list.children.map((item, i) => renderItem(item, ordered ? `${start + i}. ` : "- ")).join(sep);
+}
+// Render one list item under the given marker. A retained item (no strictly
+// deeper change) keeps its raw, only re-marking the first line so ordered
+// numbers follow the current position. An item with a dirty descendant is
+// rebuilt from its child blocks, marker on the first line and continuations
+// indented by the marker width.
+function renderItem(item, marker) {
+    if (item.children.some(hasDirtyDescendant)) {
+        const body = item.children.map((c) => (c.type === "list" ? renderList(c) : renderBlock(c, 0))).join("\n");
+        return applyMarker(body, marker);
+    }
+    return applyMarker(stripMarker(item.raw), marker);
+}
+// Remove a leading list marker + its indentation from the first line, and the
+// same indent width from continuation lines, yielding the marker-free body.
+function stripMarker(raw) {
+    const lines = raw.split("\n");
+    const m = MARKER_RE.exec(lines[0] ?? "");
+    if (!m)
+        return raw;
+    const width = m[0].length;
+    return lines
+        .map((ln, i) => (i === 0 ? ln.slice(width) : ln.slice(0, width).trim() === "" ? ln.slice(width) : ln))
+        .join("\n");
+}
+// Prepend a marker to a marker-free body: marker on the first line, the rest
+// indented by the marker width so nested content stays under the item.
+function applyMarker(body, marker) {
+    const pad = " ".repeat(marker.length);
+    return body.split("\n").map((ln, i) => (i === 0 ? marker + ln : ln.length ? pad + ln : ln)).join("\n");
+}
+/** Ordered ids of a parent's direct children (for parent_children_hash CAS). */
+export function childIds(list) {
+    return list.map((b) => b.id);
+}
+export function parentChildrenHash(list) {
+    return sha256(childIds(list).join(",")).toString("hex");
+}
+//# sourceMappingURL=tree.js.map

package/dist/src/oqx/run.d.ts

@@ -0,0 +1 @@
+export { oqxRun, oqxRunAsync, collectSemanticPhrases, parseOqx, type OqxResult, type OqxHit, type OqxOptions, type EmbedQuery, type OqxConsumer, } from "../oqx-js/run.js";

package/dist/src/oqx/run.js

@@ -0,0 +1,6 @@
+// OQX is now served by `@omgbase/oqx` (ADR-013). This module is a thin re-export
+// of the store-backed engine in ../oqx-js so every caller and the corpus keep
+// importing `../oqx/run.js` unchanged. The former in-tree compiler
+// (lexer/parser/lower/ir/compile/relations/scalar) is superseded.
+export { oqxRun, oqxRunAsync, collectSemanticPhrases, parseOqx, } from "../oqx-js/run.js";
+//# sourceMappingURL=run.js.map

package/dist/src/oqx-js/context.d.ts

@@ -0,0 +1,23 @@
+import type { DataContext } from "@omgbase/oqx";
+import type { Store } from "../core/store/store.js";
+import type { SemanticVec } from "../search/cel/compile.js";
+export type Target = "docs" | "blocks" | "nodes" | "edges";
+declare const TARGET: unique symbol;
+export interface StoreContextOptions {
+    /** Pre-computed query vectors for `semantic("phrase")`, keyed by phrase (the
+     * async runner fills this; the sync path leaves it empty and a semantic() with
+     * no entry is a loud error). */
+    semanticVectors?: Map<string, SemanticVec>;
+    /** Rows a tier-3 plan produced, bound to the residual query's synthetic
+     * `ROWS_ROOT` source (planner.ts). The rows are already target-tagged store
+     * rows, so `get`/relations/domain-fns resolve against them unchanged. */
+    rowsRoot?: {
+        name: string;
+        rows: unknown[];
+    };
+}
+export declare function makeStoreContext(store: Store, repoId: string, opts?: StoreContextOptions): DataContext;
+/** Tag SQL rows with their target so the store context resolves them (used by the
+ * tier-3 planner to hand produced rows back for residual evaluation). */
+export declare function tagRows(rows: Record<string, unknown>[], target: Target): unknown[];
+export { TARGET };