@dbsp/core 3.3.0 → 4.0.0

package/dist/internal-CNjWzMNe.d.ts

@@ -0,0 +1,177 @@
+import { TransitionLessor, ExclusiveTransitionTarget, TransitionSessionClient, TransitionQueryClient, TransitionRunMetadata, AdmittedOutcomeClaim, DestructiveAuthorityPermit, DestructiveDecision, OutcomeClaimAdmissionInput, OutcomeClaimAdmission, OutcomeProtocolRefusal, DestructiveAction, DestructiveAuthorityEvidence, OutcomeRecoveryInput, OutcomeRecoveryClassification, LedgerAddress, ClaimToken, ClaimBundleStatement, ClaimStatementBundle, OutcomeClaimPlan } from '@dbsp/types';
+
+declare const TRANSITION_LESSOR_REJECTION = "transition target must be a core-minted lessor";
+/** A core-owned lease: packs receive its session, while core retains release. */
+type TransitionLease = {
+    readonly session: TransitionSessionClient;
+    readonly release: (failure?: TransitionLeaseFailure) => Promise<void>;
+};
+/**
+ * Read the revocation bit carried by a physical lease source.
+ *
+ * This is deliberately a boolean-only adapter seam: adapters retain the
+ * physical lease through its final release, while core retains the token and
+ * every logical wrapper that shares it. An unwrapped source has not been
+ * leased, so it cannot have been marked compromised.
+ */
+declare function transitionPhysicalSessionIsCompromised(physicalSession: object): boolean;
+/**
+ * Outcome code may poison the current lease when a transport or protocol fault
+ * leaves its backend unsafe for reuse. The release boundary consumes this bit
+ * and returns the client with a truthy error so pg destroys it.
+ */
+declare function markTransitionClientCompromised(session: TransitionSessionClient): void;
+/**
+ * Mint the session passed to an operation's executeOperation() method.
+ *
+ * The returned client has the same narrow query surface as a normal session,
+ * but its provenance is carried by the lease channel selected here, not by
+ * recognizing the SQL text.  A pack never receives the unwrapped session.
+ */
+declare function planOperationSession(session: TransitionSessionClient): TransitionSessionClient;
+/**
+ * Mint a durable target from an adapter-held exclusive lease.
+ *
+ * The adapter owns the liveness closure.  Core retains the only lookup table,
+ * so a durable caller cannot substitute a generic lessor or retain a target
+ * after the adapter callback has finished.
+ */
+declare function createExclusiveTransitionTarget(target: TransitionLessor, isLive: () => boolean): ExclusiveTransitionTarget;
+/** Recognize a core-minted exclusive durable target. */
+declare function isExclusiveTransitionTarget(value: unknown): value is ExclusiveTransitionTarget;
+/** Acquire the callback-live lease underlying a durable execution target. */
+declare function acquireExclusiveTransitionLease(target: ExclusiveTransitionTarget): Promise<TransitionLease>;
+/** A non-executing transition read may use either normal or exclusive access. */
+type TransitionReadTarget = TransitionLessor | ExclusiveTransitionTarget;
+declare function acquireTransitionTargetLease(target: TransitionReadTarget): Promise<TransitionLease>;
+/**
+ * Cross the engine's acquisition boundary.
+ *
+ * A lessor brand is a declaration, not a security boundary, so every
+ * acquisition is checked here even when a caller forged that declaration.
+ */
+declare function acquireTransitionLease(target: TransitionLessor): Promise<TransitionLease>;
+/**
+ * Mint a declared source of transition leases.
+ *
+ * This declares a source of leases; it does not inspect individual
+ * acquisitions. Every acquisition crosses `acquireTransitionLease`, the
+ * runtime boundary that validates and captures it exactly once.
+ *
+ * The wrapper is allocated and frozen by core. Its non-writable,
+ * non-configurable `Symbol.for('dbsp.transition.lessor')` brand carries this
+ * protocol version, so independently installed incompatible core versions do
+ * not accept one another's lessors. The global symbol is intentionally not a
+ * security boundary: code already running in this realm can forge it. This
+ * protects callers from passing the wrong connection object by accident.
+ */
+declare function createTransitionLessor(acquire: () => Promise<TransitionQueryClient>): TransitionLessor;
+/**
+ * Recognize a core-minted transition lessor. The shape check only rejects a
+ * contradictory declaration (a branded object without acquire()); the brand
+ * and protocol version are the declaration.
+ */
+declare function isTransitionLessor(value: unknown): value is TransitionLessor;
+/**
+ * Carries the error that ended a lease's use. Its presence — not the value it
+ * holds — is what says the lease is being returned after a failure.
+ */
+type TransitionLeaseFailure = {
+    readonly error: unknown;
+};
+
+declare const durablyLoadedRunBrand: unique symbol;
+/**
+ * Core-minted evidence that run metadata passed the execution entry boundary.
+ * Its nominal member prevents accidental structural construction; the private
+ * record keeps the runtime check meaningful when JavaScript is the caller.
+ */
+interface DurablyLoadedRun {
+    readonly metadata: Readonly<TransitionRunMetadata>;
+    readonly [durablyLoadedRunBrand]: 'dbsp-durably-loaded-run';
+}
+/** Internal mint used only by the two core execution boundaries. */
+declare function mintDurablyLoadedRun(run: TransitionRunMetadata): DurablyLoadedRun;
+/** Runtime authenticity check for trusted internal consumers. */
+declare function isDurablyLoadedRun(value: unknown): value is DurablyLoadedRun;
+
+/**
+ * The total destructive classifier produces a decision for every evidence
+ * tuple; only its permitting cells produce positive destructive authority.
+ */
+declare function decideDestructiveDecision(action: DestructiveAction, evidence: DestructiveAuthorityEvidence): DestructiveDecision;
+/** Runtime defense for the erased opaque type at adapter boundaries. */
+declare function isDestructiveAuthorityPermit(permit: DestructiveAuthorityPermit): boolean;
+/**
+ * Couples the positive authority result to the existing single token producer.
+ * The adapter's destructive emitter accepts this value, never raw evidence.
+ */
+type AdmittedDestructiveOutcomeClaim = AdmittedOutcomeClaim & {
+    readonly destructivePermit: DestructiveAuthorityPermit;
+};
+declare function admitDestructiveOutcomeClaim(input: {
+    readonly decision: Extract<DestructiveDecision, {
+        readonly kind: 'destructive-decision-permitted';
+    }>;
+    readonly admission: OutcomeClaimAdmissionInput;
+}): AdmittedDestructiveOutcomeClaim | Exclude<OutcomeClaimAdmission, AdmittedOutcomeClaim>;
+/** Attach a real interpreter permit to an adapter-opened, already minted claim. */
+declare function attachDestructiveAuthorityPermit(input: {
+    readonly decision: Extract<DestructiveDecision, {
+        readonly kind: 'destructive-decision-permitted';
+    }>;
+    readonly claim: AdmittedOutcomeClaim;
+}): AdmittedDestructiveOutcomeClaim | OutcomeProtocolRefusal;
+
+/**
+ * Return the sole terminal member by predecessor topology, or undefined when
+ * the chain has zero or multiple terminals. This remains linear for large
+ * durable chains and centralizes the protocol's exactly-one-terminal rule.
+ */
+declare function findUniqueLedgerTerminal<T extends {
+    readonly eventId: string;
+    readonly predecessor?: string;
+}>(events: readonly T[]): T | undefined;
+/**
+ * The sole durable identity builder for a managed outcome claim. An address
+ * is the stable chain key, while the claim id is execution-scoped:
+ * hash(executionId, plannedClaimKey, address[, closureMemberKey]). Hashing the
+ * canonical representation keeps the persisted identifier opaque, compact,
+ * and free of serializer type tags.
+ */
+declare function outcomeClaimId(executionId: string, plannedClaimKey: string, address: LedgerAddress, closureMemberKey?: string): string;
+/** Resolution and progress ids cannot collide across execution attempts either. */
+declare function outcomeClaimEventId(claimId: string, role: string): string;
+/**
+ * The sole token producer. The documented package API does not expose managed
+ * DDL or ledger-append primitives; capability checks prevent accidental
+ * bypass within supported integrations. This is not a security boundary
+ * against code already running in this Node process or a database role
+ * authorized to issue DDL or write ledger tables.
+ */
+declare function mintClaimToken(plan: OutcomeClaimPlan): ClaimToken;
+/**
+ * Reads the claim identity of a core-minted capability without exposing its
+ * bundle or giving callers a way to mint one.
+ */
+declare function claimIdForToken(token: ClaimToken): string | undefined;
+/**
+ * Consumes exactly one planned statement. The PostgreSQL execution sink calls
+ * this immediately before it sends SQL, after it has verified the claim is
+ * still open in the ledger.
+ */
+declare function consumeClaimToken(token: ClaimToken, claimId: string, statements: readonly ClaimBundleStatement[]): ClaimStatementBundle | OutcomeProtocolRefusal;
+/**
+ * Admits an open claim from the one lifecycle grammar, and mints the execution
+ * token only after the chain and plan-time bundle have both passed.
+ */
+declare function admitOutcomeClaim(input: OutcomeClaimAdmissionInput): OutcomeClaimAdmission;
+/**
+ * Classifies one open outcome-protocol claim from a fresh catalogue read.
+ * It never issues DDL; its only mutation instruction is an append for the
+ * adapter to perform after the read has completed.  Calling this once per
+ * address deliberately keeps interrupted closures independently recoverable.
+ */
+declare function classifyOutcomeRecovery(input: OutcomeRecoveryInput): Promise<OutcomeRecoveryClassification>;
+
+export { type AdmittedDestructiveOutcomeClaim as A, type DurablyLoadedRun as D, type TransitionReadTarget as T, TRANSITION_LESSOR_REJECTION as a, type TransitionLeaseFailure as b, acquireExclusiveTransitionLease as c, acquireTransitionLease as d, acquireTransitionTargetLease as e, classifyOutcomeRecovery as f, createExclusiveTransitionTarget as g, createTransitionLessor as h, findUniqueLedgerTerminal as i, isExclusiveTransitionTarget as j, isTransitionLessor as k, outcomeClaimId as l, admitDestructiveOutcomeClaim as m, admitOutcomeClaim as n, outcomeClaimEventId as o, planOperationSession as p, attachDestructiveAuthorityPermit as q, claimIdForToken as r, consumeClaimToken as s, decideDestructiveDecision as t, isDestructiveAuthorityPermit as u, isDurablyLoadedRun as v, markTransitionClientCompromised as w, mintClaimToken as x, mintDurablyLoadedRun as y, transitionPhysicalSessionIsCompromised as z };

package/dist/internal.d.ts

@@ -0,0 +1,2 @@
+export { A as AdmittedDestructiveOutcomeClaim, D as DurablyLoadedRun, m as admitDestructiveOutcomeClaim, n as admitOutcomeClaim, q as attachDestructiveAuthorityPermit, r as claimIdForToken, s as consumeClaimToken, t as decideDestructiveDecision, u as isDestructiveAuthorityPermit, v as isDurablyLoadedRun, w as markTransitionClientCompromised, x as mintClaimToken, y as mintDurablyLoadedRun, z as transitionPhysicalSessionIsCompromised } from './internal-CNjWzMNe.js';
+import '@dbsp/types';

package/dist/internal.js

@@ -0,0 +1,99 @@
+import {
+  admitOutcomeClaim,
+  claimIdForToken,
+  consumeClaimToken,
+  isDurablyLoadedRun,
+  markTransitionClientCompromised,
+  mintClaimToken,
+  mintDurablyLoadedRun,
+  transitionPhysicalSessionIsCompromised
+} from "./chunk-AQN7HBYD.js";
+
+// src/transition/destructive-authority.ts
+import { sameLedgerAddress } from "@dbsp/types";
+var permits = /* @__PURE__ */ new WeakMap();
+function declarationPermits(action, evidence) {
+  if (action.kind === "removal")
+    return evidence.declaration === "requires-removal" || evidence.declaration === "replacement-requested-by-plan" && evidence.replacementAddress !== void 0 && sameLedgerAddress(evidence.replacementAddress, action.address);
+  return evidence.declaration === "requires-lossy-change";
+}
+function refusalReasons(action, evidence) {
+  const reasons = [];
+  if (!declarationPermits(action, evidence))
+    reasons.push("declaration does not permit this destructive action");
+  if (evidence.ownership !== "managed-by-me")
+    reasons.push(`ownership is ${evidence.ownership}`);
+  if (evidence.catalogueIdentity !== "matches-recorded")
+    reasons.push(`catalogue identity is ${evidence.catalogueIdentity}`);
+  if (evidence.operatorAcceptance !== "destructive-plan-accepted")
+    reasons.push("operator acceptance is absent");
+  if (action.kind === "removal" && evidence.containment !== "all-contained-or-managed")
+    reasons.push(
+      evidence.containment === "reaches-unmanaged" && evidence.containmentUnmanaged !== void 0 ? `containment closure is reaches-unmanaged: ${evidence.containmentUnmanaged.kind} ${evidence.containmentUnmanaged.schema ?? "<database>"}.${evidence.containmentUnmanaged.name}` : evidence.containment === "undecidable" && evidence.containmentReason !== void 0 ? `containment closure is undecidable: ${evidence.containmentReason}` : `containment closure is ${evidence.containment ?? "undecidable"}`
+    );
+  if (evidence.ledgerLineage !== "matches-database")
+    reasons.push(`ledger lineage is ${evidence.ledgerLineage}`);
+  return reasons;
+}
+function decideDestructiveDecision(action, evidence) {
+  const reasons = refusalReasons(action, evidence);
+  if (reasons.length > 0)
+    return { kind: "destructive-decision-refused", action, reasons };
+  const permit = Object.freeze({});
+  permits.set(
+    permit,
+    action.kind === "removal" && action.closureDigest !== void 0 ? { closureDigest: action.closureDigest } : {}
+  );
+  return { kind: "destructive-decision-permitted", action, permit };
+}
+function isDestructiveAuthorityPermit(permit) {
+  return permits.has(permit);
+}
+function admitDestructiveOutcomeClaim(input) {
+  if (!isDestructiveAuthorityPermit(input.decision.permit)) {
+    return {
+      kind: "outcome-protocol-refused",
+      reason: "destructive authority permit was not minted by the interpreter"
+    };
+  }
+  if (!sameLedgerAddress(
+    input.decision.action.address,
+    input.admission.plan.address
+  )) {
+    return {
+      kind: "outcome-protocol-refused",
+      reason: "destructive authority address does not match the claim address"
+    };
+  }
+  const admitted = admitOutcomeClaim(input.admission);
+  if (admitted.kind !== "admitted-outcome-claim") return admitted;
+  return { ...admitted, destructivePermit: input.decision.permit };
+}
+function attachDestructiveAuthorityPermit(input) {
+  if (!isDestructiveAuthorityPermit(input.decision.permit))
+    return {
+      kind: "outcome-protocol-refused",
+      reason: "destructive authority permit was not minted by the interpreter"
+    };
+  if (!sameLedgerAddress(input.decision.action.address, input.claim.plan.address))
+    return {
+      kind: "outcome-protocol-refused",
+      reason: "destructive authority address does not match the claim address"
+    };
+  return { ...input.claim, destructivePermit: input.decision.permit };
+}
+export {
+  admitDestructiveOutcomeClaim,
+  admitOutcomeClaim,
+  attachDestructiveAuthorityPermit,
+  claimIdForToken,
+  consumeClaimToken,
+  decideDestructiveDecision,
+  isDestructiveAuthorityPermit,
+  isDurablyLoadedRun,
+  markTransitionClientCompromised,
+  mintClaimToken,
+  mintDurablyLoadedRun,
+  transitionPhysicalSessionIsCompromised
+};
+//# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transition/destructive-authority.ts"],"sourcesContent":["import type {\n\tAdmittedOutcomeClaim,\n\tDestructiveAction,\n\tDestructiveAuthorityEvidence,\n\tDestructiveAuthorityPermit,\n\tDestructiveDecision,\n\tOutcomeClaimAdmission,\n\tOutcomeClaimAdmissionInput,\n\tOutcomeProtocolRefusal,\n} from '@dbsp/types';\nimport { sameLedgerAddress } from '@dbsp/types';\nimport { admitOutcomeClaim } from './outcome-protocol.js';\n\nconst permits = new WeakMap<object, { readonly closureDigest?: string }>();\n\nfunction declarationPermits(\n\taction: DestructiveAction,\n\tevidence: DestructiveAuthorityEvidence,\n): boolean {\n\tif (action.kind === 'removal')\n\t\treturn (\n\t\t\tevidence.declaration === 'requires-removal' ||\n\t\t\t(evidence.declaration === 'replacement-requested-by-plan' &&\n\t\t\t\tevidence.replacementAddress !== undefined &&\n\t\t\t\tsameLedgerAddress(evidence.replacementAddress, action.address))\n\t\t);\n\treturn evidence.declaration === 'requires-lossy-change';\n}\n\nfunction refusalReasons(\n\taction: DestructiveAction,\n\tevidence: DestructiveAuthorityEvidence,\n): readonly string[] {\n\tconst reasons: string[] = [];\n\tif (!declarationPermits(action, evidence))\n\t\treasons.push('declaration does not permit this destructive action');\n\tif (evidence.ownership !== 'managed-by-me')\n\t\treasons.push(`ownership is ${evidence.ownership}`);\n\tif (evidence.catalogueIdentity !== 'matches-recorded')\n\t\treasons.push(`catalogue identity is ${evidence.catalogueIdentity}`);\n\tif (evidence.operatorAcceptance !== 'destructive-plan-accepted')\n\t\treasons.push('operator acceptance is absent');\n\tif (\n\t\taction.kind === 'removal' &&\n\t\tevidence.containment !== 'all-contained-or-managed'\n\t)\n\t\treasons.push(\n\t\t\tevidence.containment === 'reaches-unmanaged' &&\n\t\t\t\tevidence.containmentUnmanaged !== undefined\n\t\t\t\t? `containment closure is reaches-unmanaged: ${evidence.containmentUnmanaged.kind} ${evidence.containmentUnmanaged.schema ?? '<database>'}.${evidence.containmentUnmanaged.name}`\n\t\t\t\t: evidence.containment === 'undecidable' &&\n\t\t\t\t\t\tevidence.containmentReason !== undefined\n\t\t\t\t\t? `containment closure is undecidable: ${evidence.containmentReason}`\n\t\t\t\t\t: `containment closure is ${evidence.containment ?? 'undecidable'}`,\n\t\t);\n\tif (evidence.ledgerLineage !== 'matches-database')\n\t\treasons.push(`ledger lineage is ${evidence.ledgerLineage}`);\n\treturn reasons;\n}\n\n/**\n * The total destructive classifier produces a decision for every evidence\n * tuple; only its permitting cells produce positive destructive authority.\n */\nexport function decideDestructiveDecision(\n\taction: DestructiveAction,\n\tevidence: DestructiveAuthorityEvidence,\n): DestructiveDecision {\n\tconst reasons = refusalReasons(action, evidence);\n\tif (reasons.length > 0)\n\t\treturn { kind: 'destructive-decision-refused', action, reasons };\n\tconst permit = Object.freeze({}) as DestructiveAuthorityPermit;\n\tpermits.set(\n\t\tpermit,\n\t\taction.kind === 'removal' && action.closureDigest !== undefined\n\t\t\t? { closureDigest: action.closureDigest }\n\t\t\t: {},\n\t);\n\treturn { kind: 'destructive-decision-permitted', action, permit };\n}\n\n/** Runtime defense for the erased opaque type at adapter boundaries. */\nexport function isDestructiveAuthorityPermit(\n\tpermit: DestructiveAuthorityPermit,\n): boolean {\n\treturn permits.has(permit);\n}\n\n/** The adapter compares this immutable admission set after taking its locks. */\nexport function closureDigestForDestructiveAuthorityPermit(\n\tpermit: DestructiveAuthorityPermit,\n): string | undefined {\n\treturn permits.get(permit)?.closureDigest;\n}\n\n/**\n * Couples the positive authority result to the existing single token producer.\n * The adapter's destructive emitter accepts this value, never raw evidence.\n */\nexport type AdmittedDestructiveOutcomeClaim = AdmittedOutcomeClaim & {\n\treadonly destructivePermit: DestructiveAuthorityPermit;\n};\n\nexport function admitDestructiveOutcomeClaim(input: {\n\treadonly decision: Extract<\n\t\tDestructiveDecision,\n\t\t{ readonly kind: 'destructive-decision-permitted' }\n\t>;\n\treadonly admission: OutcomeClaimAdmissionInput;\n}):\n\t| AdmittedDestructiveOutcomeClaim\n\t| Exclude<OutcomeClaimAdmission, AdmittedOutcomeClaim> {\n\tif (!isDestructiveAuthorityPermit(input.decision.permit)) {\n\t\treturn {\n\t\t\tkind: 'outcome-protocol-refused',\n\t\t\treason: 'destructive authority permit was not minted by the interpreter',\n\t\t};\n\t}\n\tif (\n\t\t!sameLedgerAddress(\n\t\t\tinput.decision.action.address,\n\t\t\tinput.admission.plan.address,\n\t\t)\n\t) {\n\t\treturn {\n\t\t\tkind: 'outcome-protocol-refused',\n\t\t\treason: 'destructive authority address does not match the claim address',\n\t\t};\n\t}\n\tconst admitted = admitOutcomeClaim(input.admission);\n\tif (admitted.kind !== 'admitted-outcome-claim') return admitted;\n\treturn { ...admitted, destructivePermit: input.decision.permit };\n}\n\n/** Attach a real interpreter permit to an adapter-opened, already minted claim. */\nexport function attachDestructiveAuthorityPermit(input: {\n\treadonly decision: Extract<\n\t\tDestructiveDecision,\n\t\t{ readonly kind: 'destructive-decision-permitted' }\n\t>;\n\treadonly claim: AdmittedOutcomeClaim;\n}): AdmittedDestructiveOutcomeClaim | OutcomeProtocolRefusal {\n\tif (!isDestructiveAuthorityPermit(input.decision.permit))\n\t\treturn {\n\t\t\tkind: 'outcome-protocol-refused',\n\t\t\treason: 'destructive authority permit was not minted by the interpreter',\n\t\t};\n\tif (\n\t\t!sameLedgerAddress(input.decision.action.address, input.claim.plan.address)\n\t)\n\t\treturn {\n\t\t\tkind: 'outcome-protocol-refused',\n\t\t\treason: 'destructive authority address does not match the claim address',\n\t\t};\n\treturn { ...input.claim, destructivePermit: input.decision.permit };\n}\n"],"mappings":";;;;;;;;;;;;AAUA,SAAS,yBAAyB;AAGlC,IAAM,UAAU,oBAAI,QAAqD;AAEzE,SAAS,mBACR,QACA,UACU;AACV,MAAI,OAAO,SAAS;AACnB,WACC,SAAS,gBAAgB,sBACxB,SAAS,gBAAgB,mCACzB,SAAS,uBAAuB,UAChC,kBAAkB,SAAS,oBAAoB,OAAO,OAAO;AAEhE,SAAO,SAAS,gBAAgB;AACjC;AAEA,SAAS,eACR,QACA,UACoB;AACpB,QAAM,UAAoB,CAAC;AAC3B,MAAI,CAAC,mBAAmB,QAAQ,QAAQ;AACvC,YAAQ,KAAK,qDAAqD;AACnE,MAAI,SAAS,cAAc;AAC1B,YAAQ,KAAK,gBAAgB,SAAS,SAAS,EAAE;AAClD,MAAI,SAAS,sBAAsB;AAClC,YAAQ,KAAK,yBAAyB,SAAS,iBAAiB,EAAE;AACnE,MAAI,SAAS,uBAAuB;AACnC,YAAQ,KAAK,+BAA+B;AAC7C,MACC,OAAO,SAAS,aAChB,SAAS,gBAAgB;AAEzB,YAAQ;AAAA,MACP,SAAS,gBAAgB,uBACxB,SAAS,yBAAyB,SAChC,6CAA6C,SAAS,qBAAqB,IAAI,IAAI,SAAS,qBAAqB,UAAU,YAAY,IAAI,SAAS,qBAAqB,IAAI,KAC7K,SAAS,gBAAgB,iBACzB,SAAS,sBAAsB,SAC9B,uCAAuC,SAAS,iBAAiB,KACjE,0BAA0B,SAAS,eAAe,aAAa;AAAA,IACpE;AACD,MAAI,SAAS,kBAAkB;AAC9B,YAAQ,KAAK,qBAAqB,SAAS,aAAa,EAAE;AAC3D,SAAO;AACR;AAMO,SAAS,0BACf,QACA,UACsB;AACtB,QAAM,UAAU,eAAe,QAAQ,QAAQ;AAC/C,MAAI,QAAQ,SAAS;AACpB,WAAO,EAAE,MAAM,gCAAgC,QAAQ,QAAQ;AAChE,QAAM,SAAS,OAAO,OAAO,CAAC,CAAC;AAC/B,UAAQ;AAAA,IACP;AAAA,IACA,OAAO,SAAS,aAAa,OAAO,kBAAkB,SACnD,EAAE,eAAe,OAAO,cAAc,IACtC,CAAC;AAAA,EACL;AACA,SAAO,EAAE,MAAM,kCAAkC,QAAQ,OAAO;AACjE;AAGO,SAAS,6BACf,QACU;AACV,SAAO,QAAQ,IAAI,MAAM;AAC1B;AAiBO,SAAS,6BAA6B,OAQW;AACvD,MAAI,CAAC,6BAA6B,MAAM,SAAS,MAAM,GAAG;AACzD,WAAO;AAAA,MACN,MAAM;AAAA,MACN,QAAQ;AAAA,IACT;AAAA,EACD;AACA,MACC,CAAC;AAAA,IACA,MAAM,SAAS,OAAO;AAAA,IACtB,MAAM,UAAU,KAAK;AAAA,EACtB,GACC;AACD,WAAO;AAAA,MACN,MAAM;AAAA,MACN,QAAQ;AAAA,IACT;AAAA,EACD;AACA,QAAM,WAAW,kBAAkB,MAAM,SAAS;AAClD,MAAI,SAAS,SAAS,yBAA0B,QAAO;AACvD,SAAO,EAAE,GAAG,UAAU,mBAAmB,MAAM,SAAS,OAAO;AAChE;AAGO,SAAS,iCAAiC,OAMY;AAC5D,MAAI,CAAC,6BAA6B,MAAM,SAAS,MAAM;AACtD,WAAO;AAAA,MACN,MAAM;AAAA,MACN,QAAQ;AAAA,IACT;AACD,MACC,CAAC,kBAAkB,MAAM,SAAS,OAAO,SAAS,MAAM,MAAM,KAAK,OAAO;AAE1E,WAAO;AAAA,MACN,MAAM;AAAA,MACN,QAAQ;AAAA,IACT;AACD,SAAO,EAAE,GAAG,MAAM,OAAO,mBAAmB,MAAM,SAAS,OAAO;AACnE;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbsp/core",
-  "version": "3.3.0",
+  "version": "4.0.0",
   "description": "Intent-first semantic query planner for databases — declare WHAT to fetch, the planner decides HOW",
   "author": "Olivier Orabona <oorabona@users.noreply.github.com>",
   "license": "MIT",
@@ -35,6 +35,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js"
     }
   },
   "files": [
@@ -42,8 +46,8 @@
   ],
   "dependencies": {
     "valibot": "^1.4.2",
-    "@dbsp/nql": "^1.10.2",
-    "@dbsp/types": "^3.3.0"
+    "@dbsp/nql": "^1.10.4",
+    "@dbsp/types": "^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.0",