@dbsp/core 4.0.0 → 6.0.0

package/dist/internal.d.ts

@@ -1,2 +1,330 @@
-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';
+import { BaseAdapter, ExecutingAdapter, StreamingAdapter, TransactionalAdapter, CheckConstraintIR, Comparator, ObservationContext, AdmittedOutcomeClaim, DestructiveAuthorityPermit, DestructiveDecision, OutcomeClaimAdmissionInput, OutcomeClaimAdmission, OutcomeProtocolRefusal, DestructiveAction, DestructiveAuthorityEvidence, EnumIR, EvidenceObservation, ObservationRequest, EvidenceView, ProofObligation, ExecutionContract, ExecutionRequirement, AdvisoryObservationId, AssumptionId, ClaimId, EvidenceId, SemanticArtifactId, IndexIR, LedgerHome, LedgerAddress, LedgerChainMember, LedgerChainProjection, ClaimToken, OutcomeRecoveryInput, OutcomeRecoveryClassification, ClaimBundleStatement, ClaimStatementBundle, OutcomeClaimPlan, ProvenPlanShape, Assumption, ApplyPolicy, ResourceAddress, ResourceSelector, TransitionRunMetadata, NormalizedManagedStep, TransitionFragment, ProofClaim, OperationEffectAssessment, WhereIntent, QueryIntent, PlanReport, ResolvedRange, RangeAllocator, ModelIR, ResolvedCondition, PlanDecision, SelectExecution } from '@dbsp/types';
+export { AdapterCapabilities, AdapterStreamOptions, ApplicableEvaluation, ApplyPolicy, CapabilityDescriptor, ColumnJsReadType, CompareOutcome, DumpMeta, DurableIntentRecord, ExclusiveTransitionTarget, FingerprintManifest, ForeignKeyIR, LogicalIdentity, ObservationContext, ObservationIssuer, ObservationRequest, OnDeleteAction, OperationEffectAssessment, PhysicalOperation, ProvenPlanShape, RecognitionResult, RecursivePlanReport, RelationIR, RelationType, ResourceAddress, RuleEvaluation, StepJournal, TableReaddressDeclaration, TransactionOptions, TransactionalCompletionRecord, TransitionLessor, TransitionQueryClient, TransitionRule, TransitionRunMetadata, TransitionSessionClient } from '@dbsp/types';
+import { P as PackRegistry, T as TransitionRunPersister, bu as Applier, bv as InProcessProvenPlan, bw as Prover } from './assertion-functions-DiuRuq1k.js';
+export { bx as ASSERTION_TYPES, F as AssertionBlock, by as DUCKDB_CAPABILITIES, bz as DurablyLoadedRun, bA as ExecutionCoordinator, bB as MSSQL_CAPABILITIES, bC as MYSQL_CAPABILITIES, bD as ManagedOutcomeExecutionRequest, bE as ManagedOutcomePreflightRequest, bF as NonRollbackableExecutionTracker, e as OrderByRecord, bG as RefDefinition, bH as RegisteredOperationSemantics, bI as SQLITE_CAPABILITIES, bJ as TRANSITION_LESSOR_REJECTION, bK as TransitionExecutionClient, bL as TransitionLeaseFailure, bM as TransitionPack, bN as acquireExclusiveTransitionLease, bO as acquireTransitionLease, bP as acquireTransitionTargetLease, bQ as assertCanonicalizableJson, bR as assertContains, bS as assertDbColumnExists, bT as assertDbOutput, bU as assertDbRowsEquals, bV as assertDbRowsMax, bW as assertDbRowsMin, bX as assertDbValueEquals, bY as assertIntentHasGroupBy, bZ as assertIntentHasOrderBy, b_ as assertIntentHasWhere, b$ as assertIntentTable, c0 as assertIntentType, c1 as assertIntentWith, c2 as assertMatches, c3 as assertParamsLength, c4 as assertParamsValue, c5 as assertSQLColumn, c6 as assertSQLJoin, c7 as assertSQLTable, c8 as assertSuccess, c9 as bindDeclarationSet, ca as compileNqlRead, cb as createBindingFinalPlan, cc as createExclusiveTransitionTarget, cd as createPackRegistry, ce as createTransitionLessor, cf as declarationSetFromModel, cg as isDurablyLoadedRun, ch as isExclusiveTransitionTarget, ci as isExpressionSpec, cj as isOverallSuccess, ck as isTransitionLessor, cl as isWhereIntent, cm as loadVerifiedRecoveryJournal, cn as markTransitionClientCompromised, co as mintDurablyLoadedRun, cp as normalizeRecursiveIncludeOptions, cq as objectToWhereIntent, cr as planOperationSession, cs as rawNotExists, ct as requiresDatabase, cu as resolveQueryIndex, cv as serverVersionNum, cw as stringAgg, cx as transitionPhysicalSessionIsCompromised, cy as validateDeclarationModel, cz as validateIncludeInput, cA as validateIncludeOptions, cB as validateIncludeOrdering, cC as validateIncludeStrategy, cD as validateRecursiveIncludeStrategy, cE as validateRecursiveSetOperation, cF as validateResolvedIncludeStrategy, cG as validateSchemaIndexOptions, cH as validateTypeName } from './assertion-functions-DiuRuq1k.js';
+export { CaseExpressionIntent, CompileOnlyAdapter, ConnectionAvailability, DeleteIntent, LiteralExpressionIntent, PartitionIR, RequiredEnumLabelIR, SelectAllIntent, UpdateIntent, UpsertIntent, WhereAnyIntent, WhereExistsIntent, WhereNotExistsIntent, WhereRelationFilterIntent, WhereSubqueryIntent, isSubqueryRef } from '@dbsp/types/internal';
+import '@dbsp/nql';
+
+/**
+ * Adapter interface for database adapters.
+ *
+ * Type definitions live in @dbsp/types. This module re-exports them
+ * and provides runtime functions and error classes.
+ *
+ * @module adapter
+ */
+
+/**
+ * Check if adapter supports execution.
+ */
+declare function supportsExecution(adapter: BaseAdapter): adapter is ExecutingAdapter;
+/**
+ * Check if adapter supports streaming.
+ */
+declare function supportsStreaming(adapter: BaseAdapter): adapter is StreamingAdapter;
+/**
+ * Check if adapter supports transactions.
+ */
+declare function supportsTransactions<DB>(adapter: BaseAdapter): adapter is TransactionalAdapter<DB>;
+
+declare function createApplier(registry: PackRegistry, persister: TransitionRunPersister): Applier;
+
+/**
+ * Encodes a JSON value with lexically sorted object keys and preserved array
+ * order. Unlike JSON.stringify, this refuses values it would omit or coerce.
+ */
+declare function canonicalJson(value: unknown): string;
+/** Hashes the canonical durable representation of a JSON payload. */
+declare function canonicalJsonDigest(value: unknown): string;
+
+type CheckSetEntry = Pick<CheckConstraintIR, 'name' | 'expression' | 'notValid'>;
+type CheckDelta = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'add-check';
+    readonly check: CheckSetEntry;
+    readonly expectedBefore: readonly CheckSetEntry[];
+    readonly expectedAfter: readonly CheckSetEntry[];
+} | {
+    readonly kind: 'expression-mismatch';
+    readonly desired: CheckSetEntry;
+    readonly current: CheckSetEntry;
+    readonly expectedBefore: readonly CheckSetEntry[];
+    readonly expectedAfter: readonly CheckSetEntry[];
+} | {
+    readonly kind: 'unsupported';
+};
+declare function checkDelta(desiredChecks: readonly CheckConstraintIR[] | undefined, currentChecks: readonly CheckConstraintIR[] | undefined): CheckDelta;
+
+declare function createComparator(registry: PackRegistry): Comparator;
+
+declare function observationContextDigest(context: ObservationContext): string;
+
+/**
+ * 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;
+
+type EnumAddDelta = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'add-label';
+    readonly label: string;
+    readonly after?: string;
+} | {
+    readonly kind: 'unsupported';
+};
+interface EnumAddDeltaOptions {
+    readonly targetSchema?: string;
+}
+declare function resolveEnumSchemaForComparison(enumDef: EnumIR, targetSchema?: string): EnumIR;
+declare function enumAddDelta(desired: EnumIR, current: EnumIR, options?: EnumAddDeltaOptions): EnumAddDelta;
+
+declare function createEvidenceView(params: {
+    readonly evidence: readonly EvidenceObservation[];
+    readonly context: ObservationContext;
+    readonly requests?: readonly ObservationRequest[];
+}): EvidenceView;
+
+type EvidenceConclusion = 'established' | 'undischarged' | 'refuted' | 'conflicted';
+type EvidenceEntailmentResult = {
+    readonly conclusion: EvidenceConclusion;
+    readonly supportedBy: readonly EvidenceObservation[];
+};
+declare function concludeEvidenceForObligation(params: {
+    readonly obligation: ProofObligation;
+    readonly evidence: readonly EvidenceObservation[];
+    readonly expectedContext?: ObservationContext;
+}): EvidenceEntailmentResult;
+
+/** Construct a fresh versioned contract whose requirements are canonical. */
+declare function createExecutionContract(requirements: readonly ExecutionRequirement[]): ExecutionContract;
+/** Attach a planning-time-only contract to a fresh immutable durable plan. */
+declare function bindExecutionContract(plan: InProcessProvenPlan, contract: ExecutionContract): InProcessProvenPlan;
+
+declare function semanticArtifactId(value: string): SemanticArtifactId;
+declare function assumptionId(value: string): AssumptionId;
+declare function claimId(value: string): ClaimId;
+declare function evidenceId(value: string): EvidenceId;
+declare function advisoryObservationId(value: string): AdvisoryObservationId;
+
+type IndexSetEntry = {
+    readonly name: string;
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+    readonly valid?: boolean;
+    readonly ready?: boolean;
+    readonly method?: string;
+    readonly where?: string;
+    readonly expressions?: readonly string[];
+    readonly include?: readonly string[];
+    readonly opclass?: Readonly<Record<string, string>>;
+    readonly with?: Readonly<Record<string, string>>;
+    readonly nullsNotDistinct?: boolean;
+};
+type IndexDelta = {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'add-unique-index';
+    readonly index: IndexSetEntry;
+    readonly expectedBefore: readonly IndexSetEntry[];
+    readonly expectedAfter: readonly IndexSetEntry[];
+} | {
+    readonly kind: 'unsupported';
+};
+declare function defaultIndexName(tableName: string, index: Pick<IndexIR, 'name' | 'columns'>): string;
+type IndexPerspective = 'desired' | 'current';
+declare function normalizedIndex(tableName: string, index: IndexIR, perspective?: IndexPerspective): IndexSetEntry;
+declare function indexDelta(tableName: string, desiredIndexes: readonly IndexIR[], currentIndexes: readonly IndexIR[]): IndexDelta;
+
+interface LedgerChainProjectionInput {
+    readonly ledger: LedgerHome;
+    readonly address: LedgerAddress;
+    readonly events: readonly LedgerChainMember[];
+}
+/**
+ * Projects a whole address chain without using insertion order. Malformed
+ * chains deliberately return a structured value so mutation callers fail
+ * closed while readers retain the evidence needed to diagnose it.
+ */
+declare function projectLedgerChain(input: LedgerChainProjectionInput): LedgerChainProjection;
+
+/**
+ * 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>;
+
+/**
+ * Canonical digest used to bind a durable transition run to its proven plan.
+ */
+declare function transitionPlanDigest(plan: ProvenPlanShape): string;
+
+declare function createProver(registry: PackRegistry): Prover;
+
+declare function selectorMatchesResource(selector: ResourceSelector, resource: ResourceAddress): boolean;
+declare function resourceScopeCovers(scope: readonly ResourceAddress[], required: readonly ResourceAddress[]): boolean;
+declare function assumptionAccepted(assumption: Assumption, policy: ApplyPolicy): boolean;
+
+/**
+ * Mint metadata for a proven transition before making it durable.
+ *
+ * The target digest is deliberately derived from the plan's evidence, not a
+ * caller-supplied snapshot.  That is the exact context resume verifies.
+ */
+declare function createTransitionRunMetadata(plan: InProcessProvenPlan): TransitionRunMetadata;
+
+type TransitionRelationalValidationInput = {
+    readonly kind: 'fragment';
+    readonly fragment: TransitionFragment;
+    readonly claims: readonly ProofClaim[];
+    readonly assumptions: readonly Assumption[];
+} | {
+    readonly kind: 'plan';
+    readonly plan: ProvenPlanShape;
+    readonly operationEffectsByRef?: ReadonlyMap<string, OperationEffectAssessment>;
+};
+type TransitionRelationalValidationResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+declare const validatedManagedStepManifestBrand: unique symbol;
+/** A manifest normalized and accepted by the managed lifecycle boundary. */
+interface ValidatedManagedStepManifest {
+    readonly steps: readonly NormalizedManagedStep[];
+    readonly [validatedManagedStepManifestBrand]: 'dbsp-validated-managed-step-manifest';
+}
+type ValidatedManagedStepManifestResult = {
+    readonly ok: true;
+    readonly manifest: ValidatedManagedStepManifest;
+} | {
+    readonly ok: false;
+    readonly detail: string;
+};
+/**
+ * Generic lifecycle invariants for adapter-produced normalized managed steps.
+ * Mapping a concrete DDL kind remains adapter work; core only validates the
+ * durable protocol shape before it becomes digest-covered plan material.
+ */
+declare function validateNormalizedManagedStepManifest(steps: readonly NormalizedManagedStep[]): ValidatedManagedStepManifestResult;
+/**
+ * Diagnostic consistency check for transition fragments and already-trusted,
+ * in-process plans. For plan inputs this is not an untrusted serialized-plan
+ * validator; apply() first requires the module-private minting capability, and
+ * any later plan failure is a prover bug.
+ */
+declare function validateTransitionRelationalInvariants(input: TransitionRelationalValidationInput): TransitionRelationalValidationResult;
+
+type FilterMap = Readonly<Record<string, WhereIntent>>;
+/** Copy only own entries, retaining a null prototype after range exclusions. */
+declare function copyDefaultFilters(filters: FilterMap, keep?: (table: string) => boolean): Record<string, WhereIntent>;
+
+/** Inspect enumerable own keys without consulting model metadata. */
+declare function inspectMutationRows(rows: readonly Record<string, unknown>[], options: {
+    operation: 'insert' | 'upsert' | 'update';
+    homogeneous?: boolean;
+    requiredKeys?: readonly string[];
+}): {
+    columns: string[];
+    heterogeneous: boolean;
+    rowKeys: ReadonlySet<string>[];
+};
+
+declare function getRelationalReadPlan(intent: QueryIntent, queryLocalSource?: boolean): PlanReport | undefined;
+
+/** One traversal, with one shared allocator and no reconstruction of ancestor name sets. */
+declare function resolveSelectWhere(where: WhereIntent | undefined, root: ResolvedRange, visible: readonly ResolvedRange[], allocator: RangeAllocator, model: ModelIR | undefined, initialAliasCount?: number, additionalOuterRanges?: readonly ResolvedRange[]): ResolvedCondition | undefined;
+
+/** Called during planning or once after legacy boundary validation. Never by SQL emission. */
+declare function resolveReportIncludes(intent: QueryIntent, decisions: readonly PlanDecision[], model: ModelIR | undefined, options?: {
+    defaultFilters?: Readonly<Record<string, WhereIntent>>;
+    skipRootDefaultFilter?: boolean;
+    whereReservedNames?: readonly string[];
+    defaultPk?: string;
+    deriveFk?: (table: string, pk: string) => string;
+}): SelectExecution;
+/** Include decisions retain observations only; resolved authority belongs to execution. */
+declare function observeIncludeDecisions(decisions: readonly PlanDecision[]): readonly PlanDecision[];
+
+/**
+ * Preserve hostile diagnostic text as one printable line without losing which
+ * control character was supplied. This is for diagnostics only, never SQL.
+ */
+declare function escapeDiagnosticText(value: string): string;
+
+declare class EnumNameMapKeyMismatchError extends Error {
+    readonly mapKey: string;
+    readonly enumName: string;
+    constructor(mapKey: string, enumName: string);
+}
+declare function assertDeclaredEnumMapIdentity(enums: ReadonlyMap<string, EnumIR> | undefined): void;
+
+type RelationPathUsage = {
+    readonly relationName?: string | null | undefined;
+    readonly relationPath?: string | null | undefined;
+};
+declare function deriveRelationPathFromIntentPath(includes: readonly unknown[] | undefined, intentPath: string | undefined, fallbackRelation: string | undefined): string | undefined;
+declare function countDistinctRelationPathsByName(usages: readonly RelationPathUsage[]): Map<string, number>;
+
+export { type AdmittedDestructiveOutcomeClaim, EnumNameMapKeyMismatchError, InProcessProvenPlan, PackRegistry, TransitionRunPersister, type ValidatedManagedStepManifest, admitDestructiveOutcomeClaim, admitOutcomeClaim, advisoryObservationId, assertDeclaredEnumMapIdentity, assumptionAccepted, assumptionId, attachDestructiveAuthorityPermit, bindExecutionContract, canonicalJson, canonicalJsonDigest, checkDelta, claimId, claimIdForToken, classifyOutcomeRecovery, concludeEvidenceForObligation, consumeClaimToken, copyDefaultFilters, countDistinctRelationPathsByName, createApplier, createComparator, createEvidenceView, createExecutionContract, createProver, createTransitionRunMetadata, decideDestructiveDecision, defaultIndexName, deriveRelationPathFromIntentPath, enumAddDelta, escapeDiagnosticText, evidenceId, getRelationalReadPlan, indexDelta, inspectMutationRows, isDestructiveAuthorityPermit, mintClaimToken, normalizedIndex, observationContextDigest, observeIncludeDecisions, outcomeClaimEventId, outcomeClaimId, projectLedgerChain, resolveEnumSchemaForComparison, resolveReportIncludes, resolveSelectWhere, resourceScopeCovers, selectorMatchesResource, semanticArtifactId, supportsExecution, supportsStreaming, supportsTransactions, transitionPlanDigest, validateNormalizedManagedStepManifest, validateTransitionRelationalInvariants };

package/dist/internal.js

@@ -1,13 +1,122 @@
 import {
+  ASSERTION_TYPES,
+  DUCKDB_CAPABILITIES,
+  EnumNameMapKeyMismatchError,
+  MSSQL_CAPABILITIES,
+  MYSQL_CAPABILITIES,
+  PackRegistry,
+  SQLITE_CAPABILITIES,
+  TRANSITION_LESSOR_REJECTION,
+  acquireExclusiveTransitionLease,
+  acquireTransitionLease,
+  acquireTransitionTargetLease,
   admitOutcomeClaim,
+  advisoryObservationId,
+  assertCanonicalizableJson,
+  assertContains,
+  assertDbColumnExists,
+  assertDbOutput,
+  assertDbRowsEquals,
+  assertDbRowsMax,
+  assertDbRowsMin,
+  assertDbValueEquals,
+  assertDeclaredEnumMapIdentity,
+  assertIntentHasGroupBy,
+  assertIntentHasOrderBy,
+  assertIntentHasWhere,
+  assertIntentTable,
+  assertIntentType,
+  assertIntentWith,
+  assertMatches,
+  assertParamsLength,
+  assertParamsValue,
+  assertSQLColumn,
+  assertSQLJoin,
+  assertSQLTable,
+  assertSuccess,
+  assumptionAccepted,
+  assumptionId,
+  bindDeclarationSet,
+  bindExecutionContract,
+  canonicalJson,
+  canonicalJsonDigest,
+  checkDelta,
+  claimId,
   claimIdForToken,
+  classifyOutcomeRecovery,
+  compileNqlRead,
+  concludeEvidenceForObligation,
   consumeClaimToken,
+  copyDefaultFilters,
+  countDistinctRelationPathsByName,
+  createApplier,
+  createBindingFinalPlan,
+  createComparator,
+  createEvidenceView,
+  createExclusiveTransitionTarget,
+  createExecutionContract,
+  createPackRegistry,
+  createProver,
+  createTransitionLessor,
+  createTransitionRunMetadata,
+  declarationSetFromModel,
+  defaultIndexName,
+  deriveRelationPathFromIntentPath,
+  enumAddDelta,
+  escapeDiagnosticText,
+  evidenceId,
+  getRelationalReadPlan,
+  indexDelta,
+  inspectMutationRows,
+  intent_ast_exports,
   isDurablyLoadedRun,
+  isExclusiveTransitionTarget,
+  isExpressionSpec,
+  isOverallSuccess,
+  isTransitionLessor,
+  isWhereIntent,
+  loadVerifiedRecoveryJournal,
   markTransitionClientCompromised,
   mintClaimToken,
   mintDurablyLoadedRun,
-  transitionPhysicalSessionIsCompromised
-} from "./chunk-AQN7HBYD.js";
+  normalizeRecursiveIncludeOptions,
+  normalizedIndex,
+  objectToWhereIntent,
+  observationContextDigest,
+  observeIncludeDecisions,
+  outcomeClaimEventId,
+  outcomeClaimId,
+  planOperationSession,
+  projectLedgerChain,
+  rawNotExists,
+  requiresDatabase,
+  resolveEnumSchemaForComparison,
+  resolveQueryIndex,
+  resolveReportIncludes,
+  resolveSelectWhere,
+  resourceScopeCovers,
+  selectorMatchesResource,
+  semanticArtifactId,
+  serverVersionNum,
+  stringAgg,
+  supportsExecution,
+  supportsStreaming,
+  supportsTransactions,
+  transitionPhysicalSessionIsCompromised,
+  transitionPlanDigest,
+  validateDeclarationModel,
+  validateIncludeInput,
+  validateIncludeOptions,
+  validateIncludeOrdering,
+  validateIncludeStrategy,
+  validateNormalizedManagedStepManifest,
+  validateRecursiveIncludeStrategy,
+  validateRecursiveSetOperation,
+  validateResolvedIncludeStrategy,
+  validateSchemaIndexOptions,
+  validateTransitionRelationalInvariants,
+  validateTypeName
+} from "./chunk-UATOOZ2G.js";
 
 // src/transition/destructive-authority.ts
 import { sameLedgerAddress } from "@dbsp/types";
@@ -82,18 +191,128 @@ function attachDestructiveAuthorityPermit(input) {
     };
   return { ...input.claim, destructivePermit: input.decision.permit };
 }
+var export_isSubqueryRef = intent_ast_exports.isSubqueryRef;
 export {
+  ASSERTION_TYPES,
+  DUCKDB_CAPABILITIES,
+  EnumNameMapKeyMismatchError,
+  MSSQL_CAPABILITIES,
+  MYSQL_CAPABILITIES,
+  PackRegistry,
+  SQLITE_CAPABILITIES,
+  TRANSITION_LESSOR_REJECTION,
+  acquireExclusiveTransitionLease,
+  acquireTransitionLease,
+  acquireTransitionTargetLease,
   admitDestructiveOutcomeClaim,
   admitOutcomeClaim,
+  advisoryObservationId,
+  assertCanonicalizableJson,
+  assertContains,
+  assertDbColumnExists,
+  assertDbOutput,
+  assertDbRowsEquals,
+  assertDbRowsMax,
+  assertDbRowsMin,
+  assertDbValueEquals,
+  assertDeclaredEnumMapIdentity,
+  assertIntentHasGroupBy,
+  assertIntentHasOrderBy,
+  assertIntentHasWhere,
+  assertIntentTable,
+  assertIntentType,
+  assertIntentWith,
+  assertMatches,
+  assertParamsLength,
+  assertParamsValue,
+  assertSQLColumn,
+  assertSQLJoin,
+  assertSQLTable,
+  assertSuccess,
+  assumptionAccepted,
+  assumptionId,
   attachDestructiveAuthorityPermit,
+  bindDeclarationSet,
+  bindExecutionContract,
+  canonicalJson,
+  canonicalJsonDigest,
+  checkDelta,
+  claimId,
   claimIdForToken,
+  classifyOutcomeRecovery,
+  compileNqlRead,
+  concludeEvidenceForObligation,
   consumeClaimToken,
+  copyDefaultFilters,
+  countDistinctRelationPathsByName,
+  createApplier,
+  createBindingFinalPlan,
+  createComparator,
+  createEvidenceView,
+  createExclusiveTransitionTarget,
+  createExecutionContract,
+  createPackRegistry,
+  createProver,
+  createTransitionLessor,
+  createTransitionRunMetadata,
   decideDestructiveDecision,
+  declarationSetFromModel,
+  defaultIndexName,
+  deriveRelationPathFromIntentPath,
+  enumAddDelta,
+  escapeDiagnosticText,
+  evidenceId,
+  getRelationalReadPlan,
+  indexDelta,
+  inspectMutationRows,
   isDestructiveAuthorityPermit,
   isDurablyLoadedRun,
+  isExclusiveTransitionTarget,
+  isExpressionSpec,
+  isOverallSuccess,
+  export_isSubqueryRef as isSubqueryRef,
+  isTransitionLessor,
+  isWhereIntent,
+  loadVerifiedRecoveryJournal,
   markTransitionClientCompromised,
   mintClaimToken,
   mintDurablyLoadedRun,
-  transitionPhysicalSessionIsCompromised
+  normalizeRecursiveIncludeOptions,
+  normalizedIndex,
+  objectToWhereIntent,
+  observationContextDigest,
+  observeIncludeDecisions,
+  outcomeClaimEventId,
+  outcomeClaimId,
+  planOperationSession,
+  projectLedgerChain,
+  rawNotExists,
+  requiresDatabase,
+  resolveEnumSchemaForComparison,
+  resolveQueryIndex,
+  resolveReportIncludes,
+  resolveSelectWhere,
+  resourceScopeCovers,
+  selectorMatchesResource,
+  semanticArtifactId,
+  serverVersionNum,
+  stringAgg,
+  supportsExecution,
+  supportsStreaming,
+  supportsTransactions,
+  transitionPhysicalSessionIsCompromised,
+  transitionPlanDigest,
+  validateDeclarationModel,
+  validateIncludeInput,
+  validateIncludeOptions,
+  validateIncludeOrdering,
+  validateIncludeStrategy,
+  validateNormalizedManagedStepManifest,
+  validateRecursiveIncludeStrategy,
+  validateRecursiveSetOperation,
+  validateResolvedIncludeStrategy,
+  validateSchemaIndexOptions,
+  validateTransitionRelationalInvariants,
+  validateTypeName
 };
 //# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -1 +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":[]}
+{"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": "4.0.0",
+  "version": "6.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",
@@ -45,15 +45,15 @@
     "dist"
   ],
   "dependencies": {
-    "valibot": "^1.4.2",
-    "@dbsp/nql": "^1.10.4",
-    "@dbsp/types": "^4.0.0"
+    "@dbsp/nql": "^2.0.0",
+    "@dbsp/types": "^6.0.0",
+    "valibot": "^1.4.2"
   },
   "devDependencies": {
     "@types/node": "^26.1.0",
     "tsup": "^8.5.1",
     "typescript": "~6.0.3",
-    "vitest": "^4.1.9"
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "build": "tsup",