graphddb 0.2.0 → 0.2.1

package/dist/{chunk-347U24SB.js → chunk-PWV7JDMR.js}

@@ -525,6 +525,51 @@ var TableMapping = class {
   }
 };
 
+// src/define/param.ts
+function makeParam(kind, literals) {
+  return literals === void 0 ? { kind } : { kind, literals };
+}
+var param = {
+  /** A placeholder for a `string` value. */
+  string() {
+    return makeParam("string");
+  },
+  /** A placeholder for a `number` value. */
+  number() {
+    return makeParam("number");
+  },
+  /**
+   * A placeholder constrained to one of the given literal values. The value
+   * type of the resulting {@link Param} is the **union of the literals**, so it
+   * is preserved precisely in the IR and the inferred definition types.
+   *
+   * @example
+   * ```ts
+   * param.literal('active', 'disabled'); // Param<'active' | 'disabled'>
+   * ```
+   */
+  literal(...values) {
+    return makeParam("literal", values);
+  },
+  /**
+   * A placeholder for an **array** parameter whose elements have the given field
+   * shape. Used by `defineTransaction`'s `tx.forEach(p.<arrayParam>, …)` to bind
+   * each element's fields to `{item.<field>}` templates.
+   *
+   * @example
+   * ```ts
+   * param.array({ userId: param.string(), role: param.string() });
+   * // Param<{ userId: string; role: string }[]>
+   * ```
+   */
+  array(element) {
+    return { kind: "array", element };
+  }
+};
+function isParam(value) {
+  return typeof value === "object" && value !== null && "kind" in value && (value.kind === "string" || value.kind === "number" || value.kind === "literal" || value.kind === "array");
+}
+
 // src/client/lib-dynamodb.ts
 var cached = null;
 async function loadLibDynamoDB() {
@@ -825,20 +870,20 @@ async function executeQuery(docClient, operation) {
   };
   for (let i = 0; i < keyEntries.length; i++) {
     const [attrName, value] = keyEntries[i];
-    const nameAlias = `#k${i}`;
-    const valueAlias = `:k${i}`;
-    exprAttrNames[nameAlias] = attrName;
-    exprAttrValues[valueAlias] = value;
-    conditionParts.push(`${nameAlias} = ${valueAlias}`);
+    const nameAlias2 = `#k${i}`;
+    const valueAlias2 = `:k${i}`;
+    exprAttrNames[nameAlias2] = attrName;
+    exprAttrValues[valueAlias2] = value;
+    conditionParts.push(`${nameAlias2} = ${valueAlias2}`);
   }
   if (operation.rangeCondition) {
     const rc = operation.rangeCondition;
     const idx = keyEntries.length;
-    const nameAlias = `#k${idx}`;
-    const valueAlias = `:k${idx}`;
-    exprAttrNames[nameAlias] = rc.key;
-    exprAttrValues[valueAlias] = rc.value;
-    conditionParts.push(`begins_with(${nameAlias}, ${valueAlias})`);
+    const nameAlias2 = `#k${idx}`;
+    const valueAlias2 = `:k${idx}`;
+    exprAttrNames[nameAlias2] = rc.key;
+    exprAttrValues[valueAlias2] = rc.value;
+    conditionParts.push(`begins_with(${nameAlias2}, ${valueAlias2})`);
   }
   const cmd = new QueryCommand({
     TableName: operation.tableName,
@@ -860,14 +905,290 @@ async function executeQuery(docClient, operation) {
   };
 }
 
+// src/select/cond.ts
+var RAW_COND = /* @__PURE__ */ Symbol.for("graphddb.rawCond");
+function isRawCondition(value) {
+  return typeof value === "object" && value !== null && value[RAW_COND] === true;
+}
+function cond(template, ...parts) {
+  return {
+    [RAW_COND]: true,
+    template,
+    parts
+  };
+}
+function compileRawCondition(raw, allocName, allocValue) {
+  let out = raw.template[0];
+  for (let i = 0; i < raw.parts.length; i++) {
+    const part = raw.parts[i];
+    if (isColumn(part)) {
+      out += allocName(part.name);
+    } else {
+      out += allocValue(part);
+    }
+    out += raw.template[i + 1];
+  }
+  return out;
+}
+function condParamName(index) {
+  return `cond_p${index}`;
+}
+function serializeRawCondition(raw, renderSlot) {
+  const names = {};
+  const values = {};
+  let valueCounter = 0;
+  let paramIndex = 0;
+  const nameAlias2 = (column) => {
+    const alias = `#cr_${column}`;
+    names[alias] = column;
+    return alias;
+  };
+  const valueAlias2 = (value) => {
+    const alias = `:cr${valueCounter++}`;
+    values[alias] = value;
+    return alias;
+  };
+  let out = raw.template[0];
+  for (let i = 0; i < raw.parts.length; i++) {
+    const part = raw.parts[i];
+    if (isColumn(part)) {
+      out += nameAlias2(part.name);
+    } else {
+      const custom = renderSlot?.(part, paramIndex);
+      if (custom !== void 0) {
+        if (isParam(part)) paramIndex++;
+        out += valueAlias2(custom);
+      } else if (isParam(part)) {
+        out += valueAlias2({ $param: condParamName(paramIndex++) });
+      } else if (part instanceof Date) {
+        out += valueAlias2(part.toISOString());
+      } else {
+        out += valueAlias2(part);
+      }
+    }
+    out += raw.template[i + 1];
+  }
+  return { expression: out, names, values };
+}
+function collectRawConditionParams(raw) {
+  const out = [];
+  let paramIndex = 0;
+  for (const part of raw.parts) {
+    if (isColumn(part)) continue;
+    if (isParam(part)) {
+      out.push({ name: condParamName(paramIndex++), param: part });
+    }
+  }
+  return out;
+}
+
 // src/expression/condition-expression.ts
+var OPERATOR_KEYS = /* @__PURE__ */ new Set([
+  "eq",
+  "ne",
+  "gt",
+  "ge",
+  "lt",
+  "le",
+  "between",
+  "in",
+  "beginsWith",
+  "contains",
+  "notContains",
+  "attributeExists",
+  "attributeType",
+  "size"
+]);
+function nameAlias(ctx, field) {
+  const alias = `#cond_${field}`;
+  ctx.names[alias] = field;
+  return alias;
+}
+function valueAlias(ctx, value) {
+  const alias = `:cond${ctx.valueCounter.n++}`;
+  ctx.values[alias] = value;
+  return alias;
+}
+function isOperatorObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date || value instanceof Uint8Array || value instanceof Set) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 0) return false;
+  return keys.every((k2) => OPERATOR_KEYS.has(k2));
+}
+function joinAnd(clauses) {
+  if (clauses.length === 1) return clauses[0];
+  return clauses.map((c) => wrap(c)).join(" AND ");
+}
+function wrap(expr) {
+  if (isAlreadyWrapped(expr)) return expr;
+  if (expr.includes(" AND ") || expr.includes(" OR ")) return `(${expr})`;
+  return expr;
+}
+function isAlreadyWrapped(expr) {
+  if (!expr.startsWith("(") || !expr.endsWith(")")) return false;
+  let depth = 0;
+  for (let i = 0; i < expr.length; i++) {
+    if (expr[i] === "(") depth++;
+    else if (expr[i] === ")") {
+      depth--;
+      if (depth === 0 && i < expr.length - 1) return false;
+    }
+  }
+  return depth === 0;
+}
+function compileField(ctx, field, condition) {
+  const n = nameAlias(ctx, field);
+  if (!isOperatorObject(condition)) {
+    return `${n} = ${valueAlias(ctx, condition)}`;
+  }
+  const ops = condition;
+  const clauses = [];
+  for (const [op, value] of Object.entries(ops)) {
+    switch (op) {
+      case "eq":
+        clauses.push(`${n} = ${valueAlias(ctx, value)}`);
+        break;
+      case "ne":
+        clauses.push(`${n} <> ${valueAlias(ctx, value)}`);
+        break;
+      case "gt":
+        clauses.push(`${n} > ${valueAlias(ctx, value)}`);
+        break;
+      case "ge":
+        clauses.push(`${n} >= ${valueAlias(ctx, value)}`);
+        break;
+      case "lt":
+        clauses.push(`${n} < ${valueAlias(ctx, value)}`);
+        break;
+      case "le":
+        clauses.push(`${n} <= ${valueAlias(ctx, value)}`);
+        break;
+      case "between": {
+        const [lo, hi] = value;
+        clauses.push(
+          `${n} BETWEEN ${valueAlias(ctx, lo)} AND ${valueAlias(ctx, hi)}`
+        );
+        break;
+      }
+      case "in": {
+        const aliases = value.map((v) => valueAlias(ctx, v));
+        clauses.push(`${n} IN (${aliases.join(", ")})`);
+        break;
+      }
+      case "beginsWith":
+        clauses.push(`begins_with(${n}, ${valueAlias(ctx, value)})`);
+        break;
+      case "contains":
+        clauses.push(`contains(${n}, ${valueAlias(ctx, value)})`);
+        break;
+      case "notContains":
+        clauses.push(`NOT contains(${n}, ${valueAlias(ctx, value)})`);
+        break;
+      case "attributeExists":
+        clauses.push(
+          value === false ? `attribute_not_exists(${n})` : `attribute_exists(${n})`
+        );
+        break;
+      case "attributeType":
+        clauses.push(`attribute_type(${n}, ${valueAlias(ctx, value)})`);
+        break;
+      case "size":
+        clauses.push(`size(${n}) = ${valueAlias(ctx, value)}`);
+        break;
+      default:
+        throw new Error(`Unknown condition operator '${op}' on field '${field}'`);
+    }
+  }
+  return joinAnd(clauses);
+}
+function compileRaw(ctx, raw) {
+  return compileRawCondition(
+    raw,
+    (column) => nameAlias(ctx, column),
+    (value) => valueAlias(ctx, value)
+  );
+}
+function compileNode(ctx, node) {
+  if (isRawCondition(node)) {
+    return compileRaw(ctx, node);
+  }
+  const clauses = [];
+  for (const [key2, value] of Object.entries(node)) {
+    if (value === void 0) continue;
+    if (key2 === "and" || key2 === "or") {
+      const parts = value.map((sub) => compileNode(ctx, sub)).filter((s) => s.length > 0);
+      if (parts.length === 0) continue;
+      if (parts.length === 1) {
+        clauses.push(parts[0]);
+      } else {
+        const sep = key2 === "and" ? " AND " : " OR ";
+        clauses.push(`(${parts.map((p) => wrap(p)).join(sep)})`);
+      }
+      continue;
+    }
+    if (key2 === "not") {
+      const inner = compileNode(ctx, value);
+      if (inner.length > 0) clauses.push(`NOT ${wrap(inner)}`);
+      continue;
+    }
+    const clause = compileField(ctx, key2, value);
+    if (clause.length > 0) clauses.push(clause);
+  }
+  return joinAnd(clauses);
+}
+function resolveConditionTree(declarative, resolveParam) {
+  return resolveNode(declarative, resolveParam);
+}
+function isParamLeaf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.$param === "string";
+}
+function resolveLeaf(value, resolveParam) {
+  if (isParamLeaf(value)) return resolveParam(value.$param);
+  return value;
+}
+function resolveNode(node, resolveParam) {
+  const obj = node;
+  const out = {};
+  for (const [key2, value] of Object.entries(obj)) {
+    if (key2 === "and" || key2 === "or") {
+      out[key2] = value.map((s) => resolveNode(s, resolveParam));
+    } else if (key2 === "not") {
+      out[key2] = resolveNode(value, resolveParam);
+    } else {
+      const ops = value;
+      const rendered = {};
+      for (const [op, opVal] of Object.entries(ops)) {
+        if (op === "between") {
+          const [lo, hi] = opVal;
+          rendered[op] = [
+            resolveLeaf(lo, resolveParam),
+            resolveLeaf(hi, resolveParam)
+          ];
+        } else if (op === "in") {
+          rendered[op] = opVal.map(
+            (v) => resolveLeaf(v, resolveParam)
+          );
+        } else if (op === "attributeExists") {
+          rendered[op] = opVal;
+        } else {
+          rendered[op] = resolveLeaf(opVal, resolveParam);
+        }
+      }
+      out[key2] = rendered;
+    }
+  }
+  return out;
+}
 function buildConditionExpression(condition) {
+  if (isRawCondition(condition)) {
+    const ctx2 = { names: {}, values: {}, valueCounter: { n: 0 } };
+    const expression2 = compileRaw(ctx2, condition);
+    return { expression: expression2, names: ctx2.names, values: ctx2.values };
+  }
   if (condition.notExists === true) {
-    return {
-      expression: "attribute_not_exists(PK)",
-      names: {},
-      values: {}
-    };
+    return { expression: "attribute_not_exists(PK)", names: {}, values: {} };
   }
   if (typeof condition.attributeExists === "string") {
     const field = condition.attributeExists;
@@ -887,22 +1208,9 @@ function buildConditionExpression(condition) {
       values: {}
     };
   }
-  const clauses = [];
-  const names = {};
-  const values = {};
-  let counter = 0;
-  for (const [fieldName, value] of Object.entries(condition)) {
-    const nameKey = `#cond_${fieldName}`;
-    const valueKey = `:cond${counter++}`;
-    names[nameKey] = fieldName;
-    values[valueKey] = value;
-    clauses.push(`${nameKey} = ${valueKey}`);
-  }
-  return {
-    expression: clauses.join(" AND "),
-    names,
-    values
-  };
+  const ctx = { names: {}, values: {}, valueCounter: { n: 0 } };
+  const expression = compileNode(ctx, condition);
+  return { expression, names: ctx.names, values: ctx.values };
 }
 
 // src/operations/serialize.ts
@@ -1719,17 +2027,17 @@ var TransactionContext = class {
     this.assertWithinLimit();
     const modelClass = resolveModelClass(model);
     const { TableName, Key } = buildDeleteInput(modelClass, key2);
-    const cond = buildConditionExpression(options.condition);
+    const cond2 = buildConditionExpression(options.condition);
     const check = {
       TableName,
       Key,
-      ConditionExpression: cond.expression
+      ConditionExpression: cond2.expression
     };
-    if (Object.keys(cond.names).length > 0) {
-      check.ExpressionAttributeNames = cond.names;
+    if (Object.keys(cond2.names).length > 0) {
+      check.ExpressionAttributeNames = cond2.names;
     }
-    if (Object.keys(cond.values).length > 0) {
-      check.ExpressionAttributeValues = cond.values;
+    if (Object.keys(cond2.values).length > 0) {
+      check.ExpressionAttributeValues = cond2.values;
     }
     this.items.push({ ConditionCheck: check });
   }
@@ -1791,10 +2099,18 @@ export {
   pkTemplate,
   skTemplate,
   resolveSegmentedKey,
+  param,
+  isParam,
   BATCH_GET_MAX_KEYS,
   BATCH_WRITE_MAX_ITEMS,
   DynamoExecutor,
   ClientManager,
+  isRawCondition,
+  cond,
+  compileRawCondition,
+  serializeRawCondition,
+  collectRawConditionParams,
+  resolveConditionTree,
   buildConditionExpression,
   serializeFieldValue,
   ChangeCaptureRegistry,

package/dist/{chunk-UNRQ5YJT.js → chunk-SBNP62H7.js}

@@ -1,7 +1,7 @@
 import {
   ChangeCaptureRegistry,
   resolveModelClass
-} from "./chunk-347U24SB.js";
+} from "./chunk-PWV7JDMR.js";
 
 // src/cdc/prng.ts
 var SeededRandom = class {

package/dist/cli.js

@@ -2,10 +2,10 @@
 import {
   buildBridgeBundle,
   normalizeSelectSpec
-} from "./chunk-F27INYI2.js";
+} from "./chunk-4B4MUPUJ.js";
 import {
   MetadataRegistry
-} from "./chunk-347U24SB.js";
+} from "./chunk-PWV7JDMR.js";
 
 // src/cli.ts
 import { createRequire } from "module";

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { S as SelectableOf, f as PrimaryKeyOf, E as Executor, g as ExecutionPlanSpec, h as SegmentedKey, i as SelectBuilderSpec, j as TransactionSpec, k as Manifest, l as ExecutionPlan, R as ResolvedKey, D as DynamoDBOperation, a as ExecutorResult, B as BatchGetExecInput, P as PutInput, W as WriteExecOptions, b as WriteResult, U as UpdateInput, c as DeleteInput, d as BatchWriteExecItem, T as TransactWriteExecItem, m as CdcEmulatorOptions, n as ChangeHandler, o as Unsubscribe, F as FaultSpec, p as ConcurrentRecomputeRef, C as ChangeEvent, q as EventLog, r as ReplayOptions, s as ShardId, t as TransactionItemSpec, u as Param, v as ParamDescriptor, w as DefinitionMap, O as OperationDefinition, e as DDBModel, M as ModelStatic, x as WriteDefinitionOptions, y as PartialQueryKeyOf, z as StrictSelectSpec, A as EntityInput, G as UniqueQueryKeyOf, H as EntityRef, I as ConditionInput, Q as QueryModelContract, J as QueryMethodSpec, K as CommandModelContract, L as CommandMethodSpec, N as ContractSpec, V as QuerySpec, X as CommandSpec, Y as ContextSpec, Z as OperationsDocument, _ as AnyOperationDefinition, $ as BridgeBundle, a0 as ConditionSpec } from './types-D6qLpw2M.js';
-export { a1 as BatchDeleteRequest, a2 as BatchGetRequest, a3 as BatchGetResult, a4 as BatchPutRequest, a5 as BatchResult, a6 as BatchWriteRequest, a7 as CONTRACT_RANGE_FANOUT_CONCURRENCY, a8 as CdcMode, a9 as ChangeBatch, aa as ChangeEventName, ab as ClockMode, ac as Column, ad as ColumnMap, ae as CommandContractMethodSpec, af as CommandInputShape, ag as CommandMethod, ah as CommandPlan, ai as CommandResolutionTarget, aj as CommandResultKind, ak as CommandSelectShape, al as CompiledFragment, am as ComposeSpec, an as CondSlot, ao as ConditionCheckInput, ap as Connection, aq as ContractCallSignature, ar as ContractCardinality, as as ContractCommandParams, at as ContractCommandResult, au as ContractComposeNode, av as ContractFromRef, aw as ContractInputArity, ax as ContractItem, ay as ContractKeyFieldRef, az as ContractKeyInput, aA as ContractKeyRef, aB as ContractKeySpec, aC as ContractKind, aD as ContractMethodOp, aE as ContractParamRef, aF as ContractQueryParams, aG as ContractResolution, aH as DeleteOptions, aI as DeriveEffect, aJ as DerivedEdgeWrite, aK as DerivedUpdate, aL as DescriptorBinding, aM as ENTITY_WRITES_MARKER, aN as EdgeEffect, aO as EffectPath, aP as EmitEffect, aQ as EntityWritesDefinition, aR as EntityWritesShape, aS as ExecutableCommandContract, aT as ExecutableQueryContract, aU as FilterInput, aV as FilterSpec, aW as FragmentInput, aX as GsiDefinitionMarker, aY as GsiOptions, aZ as IdempotencyEffect, a_ as InProcessWriteDescriptor, a$ as InputArity, b0 as KeyDefinitionMarker, b1 as KeySegment, b2 as KeySlot, b3 as KeyStructure, b4 as KeyedResult, b5 as LIFECYCLE_CONTRACT_MARKER, b6 as LifecycleContract, b7 as LifecycleEffects, b8 as LiteralParam, b9 as ManifestEntity, ba as ManifestField, bb as ManifestFieldType, bc as ManifestGsi, bd as ManifestKey, be as ManifestRelation, bf as ManifestTable, bg as ModelRef, bh as MutateMode, bi as MutateOptions, bj as MutateParallelResult, bk as MutateTransactionResult, bl as MutationBody, bm as MutationDescriptorMap, bn as MutationFragment, bo as MutationInputProxy, bp as MutationInputRef, bq as MutationIntent, br as NumberParam, bs as OperationKind, bt as OperationSpec, bu as ParallelOpResult, bv as ParamKind, bw as ParamSpec, bx as ParamStructure, by as PlannedCommandMethod, bz as PutOptions, bA as QueryContractMethodSpec, bB as QueryEnvelopeResult, bC as QueryKeyOf, bD as QueryMethod, bE as QueryResult, bF as RangeConditionSpec, bG as RawCondition, bH as ReadEnvelope, bI as ReadOperationType, bJ as ReadRouteDescriptor, bK as ReadRouteOptions, bL as ReadRouteResult, bM as RecordedCompose, bN as RelationBuilder, bO as RelationSelect, bP as RelationSpec, bQ as RequiresEffect, bR as Resolution, bS as SPEC_VERSION, bT as SegmentSpec, bU as SelectBuilder, bV as SelectOf, bW as StartingPosition, bX as StreamViewType, bY as StringParam, bZ as TransactionContext, b_ as TransactionItemType, b$ as UniqueEffect, c0 as Updatable, c1 as UpdateOptions, c2 as WhenSpec, c3 as WriteDescriptor, c4 as WriteEnvelope, c5 as WriteLifecyclePhase, c6 as WriteOperationType, c7 as WriteRecorder, c8 as WriteResultProjection, c9 as attachModelClass, ca as buildDeleteInput, cb as buildPutInput, cc as buildUpdateInput, cd as compileFragment, ce as compileMutationPlan, cf as compileSingleFragmentPlan, cg as cond, ch as contractOfMethodSpec, ci as definePlan, cj as entityWrites, ck as executeBatchGet, cl as executeBatchWrite, cm as executeCommandMethod, cn as executeDelete, co as executeKeyedBatchGet, cp as executePut, cq as executeQueryMethod, cr as executeRangeFanout, cs as executeTransaction, ct as executeUpdate, cu as from, cv as getEntityWrites, cw as gsi, cx as isColumn, cy as isCommandModelContract, cz as isCommandPlan, cA as isContractComposeNode, cB as isContractFromRef, cC as isContractKeyFieldRef, cD as isContractKeyRef, cE as isContractParamRef, cF as isEntityWritesDefinition, cG as isKeySegment, cH as isLifecycleContract, cI as isMutationFragment, cJ as isMutationInputRef, cK as isParam, cL as isPlannedCommandMethod, cM as isQueryModelContract, cN as k, cO as key, cP as lifecyclePhaseForIntent, cQ as mintContractKeyFieldRef, cR as mintContractParamRef, cS as mutation, cT as param, cU as publicCommandModel, cV as publicQueryModel, cW as query, cX as resolveLifecycle, cY as wholeKeysSentinel } from './types-D6qLpw2M.js';
+import { S as SelectableOf, f as PrimaryKeyOf, E as Executor, g as ExecutionPlanSpec, h as SegmentedKey, i as SelectBuilderSpec, R as RawCondition, j as TransactionSpec, k as Manifest, l as ExecutionPlan, m as ResolvedKey, D as DynamoDBOperation, a as ExecutorResult, B as BatchGetExecInput, P as PutInput, W as WriteExecOptions, b as WriteResult, U as UpdateInput, c as DeleteInput, d as BatchWriteExecItem, T as TransactWriteExecItem, n as CdcEmulatorOptions, o as ChangeHandler, p as Unsubscribe, F as FaultSpec, q as ConcurrentRecomputeRef, C as ChangeEvent, r as EventLog, s as ReplayOptions, t as ShardId, u as TransactionItemSpec, v as Param, w as ParamDescriptor, x as DefinitionMap, O as OperationDefinition, e as DDBModel, M as ModelStatic, y as WriteDefinitionOptions, z as PartialQueryKeyOf, A as StrictSelectSpec, G as EntityInput, H as UniqueQueryKeyOf, I as EntityRef, J as ConditionInput, Q as QueryModelContract, K as QueryMethodSpec, L as CommandModelContract, N as CommandMethodSpec, V as ContractSpec, X as QuerySpec, Y as CommandSpec, Z as ContextSpec, _ as OperationsDocument, $ as AnyOperationDefinition, a0 as BridgeBundle, a1 as ConditionSpec } from './types-DPJ4tPjX.js';
+export { a2 as BatchDeleteRequest, a3 as BatchGetRequest, a4 as BatchGetResult, a5 as BatchPutRequest, a6 as BatchResult, a7 as BatchWriteRequest, a8 as CONTRACT_RANGE_FANOUT_CONCURRENCY, a9 as CdcMode, aa as ChangeBatch, ab as ChangeEventName, ac as ClockMode, ad as Column, ae as ColumnMap, af as CommandContractMethodSpec, ag as CommandInputShape, ah as CommandMethod, ai as CommandPlan, aj as CommandResolutionTarget, ak as CommandResultKind, al as CommandSelectShape, am as CompiledFragment, an as ComposeSpec, ao as CondSlot, ap as ConditionCheckInput, aq as Connection, ar as ContractCallSignature, as as ContractCardinality, at as ContractCommandParams, au as ContractCommandResult, av as ContractComposeNode, aw as ContractFromRef, ax as ContractInputArity, ay as ContractItem, az as ContractKeyFieldRef, aA as ContractKeyInput, aB as ContractKeyRef, aC as ContractKeySpec, aD as ContractKind, aE as ContractMethodOp, aF as ContractParamRef, aG as ContractQueryParams, aH as ContractResolution, aI as DeleteOptions, aJ as DeriveEffect, aK as DerivedEdgeWrite, aL as DerivedUpdate, aM as DescriptorBinding, aN as ENTITY_WRITES_MARKER, aO as EdgeEffect, aP as EffectPath, aQ as EmitEffect, aR as EntityWritesDefinition, aS as EntityWritesShape, aT as ExecutableCommandContract, aU as ExecutableQueryContract, aV as FilterInput, aW as FilterSpec, aX as FragmentInput, aY as GsiDefinitionMarker, aZ as GsiOptions, a_ as IdempotencyEffect, a$ as InProcessWriteDescriptor, b0 as InputArity, b1 as KeyDefinitionMarker, b2 as KeySegment, b3 as KeySlot, b4 as KeyStructure, b5 as KeyedResult, b6 as LIFECYCLE_CONTRACT_MARKER, b7 as LifecycleContract, b8 as LifecycleEffects, b9 as LiteralParam, ba as ManifestEntity, bb as ManifestField, bc as ManifestFieldType, bd as ManifestGsi, be as ManifestKey, bf as ManifestRelation, bg as ManifestTable, bh as ModelRef, bi as MutateMode, bj as MutateOptions, bk as MutateParallelResult, bl as MutateTransactionResult, bm as MutationBody, bn as MutationDescriptorMap, bo as MutationFragment, bp as MutationInputProxy, bq as MutationInputRef, br as MutationIntent, bs as NumberParam, bt as OperationKind, bu as OperationSpec, bv as ParallelOpResult, bw as ParamKind, bx as ParamSpec, by as ParamStructure, bz as PlannedCommandMethod, bA as PutOptions, bB as QueryContractMethodSpec, bC as QueryEnvelopeResult, bD as QueryKeyOf, bE as QueryMethod, bF as QueryResult, bG as RangeConditionSpec, bH as ReadEnvelope, bI as ReadOperationType, bJ as ReadRouteDescriptor, bK as ReadRouteOptions, bL as ReadRouteResult, bM as RecordedCompose, bN as RelationBuilder, bO as RelationSelect, bP as RelationSpec, bQ as RequiresEffect, bR as Resolution, bS as SPEC_VERSION, bT as SegmentSpec, bU as SelectBuilder, bV as SelectOf, bW as StartingPosition, bX as StreamViewType, bY as StringParam, bZ as TransactionContext, b_ as TransactionItemType, b$ as UniqueEffect, c0 as Updatable, c1 as UpdateOptions, c2 as WhenSpec, c3 as WriteDescriptor, c4 as WriteEnvelope, c5 as WriteLifecyclePhase, c6 as WriteOperationType, c7 as WriteRecorder, c8 as WriteResultProjection, c9 as attachModelClass, ca as buildDeleteInput, cb as buildPutInput, cc as buildUpdateInput, cd as compileFragment, ce as compileMutationPlan, cf as compileSingleFragmentPlan, cg as cond, ch as contractOfMethodSpec, ci as definePlan, cj as entityWrites, ck as executeBatchGet, cl as executeBatchWrite, cm as executeCommandMethod, cn as executeDelete, co as executeKeyedBatchGet, cp as executePut, cq as executeQueryMethod, cr as executeRangeFanout, cs as executeTransaction, ct as executeUpdate, cu as from, cv as getEntityWrites, cw as gsi, cx as isColumn, cy as isCommandModelContract, cz as isCommandPlan, cA as isContractComposeNode, cB as isContractFromRef, cC as isContractKeyFieldRef, cD as isContractKeyRef, cE as isContractParamRef, cF as isEntityWritesDefinition, cG as isKeySegment, cH as isLifecycleContract, cI as isMutationFragment, cJ as isMutationInputRef, cK as isParam, cL as isPlannedCommandMethod, cM as isQueryModelContract, cN as k, cO as key, cP as lifecyclePhaseForIntent, cQ as mintContractKeyFieldRef, cR as mintContractParamRef, cS as mutation, cT as param, cU as publicCommandModel, cV as publicQueryModel, cW as query, cX as resolveLifecycle, cY as wholeKeysSentinel } from './types-DPJ4tPjX.js';
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 
@@ -420,22 +420,8 @@ interface ConditionExpressionResult {
     names: Record<string, string>;
     values: Record<string, unknown>;
 }
-/**
- * Build a DynamoDB ConditionExpression from a condition object (issues #46, #81).
- *
- * - `{ notExists: true }` → `attribute_not_exists(PK)` (legacy whole-row guard)
- * - `{ attributeExists: 'email' }` → `attribute_exists(#cond_email)` (any field,
- *   incl. PK/SK)
- * - `{ attributeNotExists: 'email' }` → `attribute_not_exists(#cond_email)`
- * - `{ version: 3 }` → `#cond_version = :cond0`
- * - `{ version: 3, status: 'active' }` → `#cond_version = :cond0 AND #cond_status = :cond1`
- *
- * Attribute name/value keys use the `cond_` prefix to avoid collisions with
- * UpdateExpression names/values. The existence primitives go through a `#name`
- * placeholder rather than a bare attribute so reserved-word fields (and PK/SK)
- * are always legal.
- */
-declare function buildConditionExpression(condition: Record<string, unknown>): ConditionExpressionResult;
+
+declare function buildConditionExpression(condition: Record<string, unknown> | RawCondition): ConditionExpressionResult;
 
 /**
  * Compiled DynamoDB `FilterExpression`. Names are `#`-aliased column
@@ -2047,4 +2033,4 @@ declare function assertBundleSerializable(bundle: BridgeBundle): void;
  */
 declare function buildBridgeBundle(queries?: DefinitionMap, commands?: DefinitionMap, registry?: typeof MetadataRegistry, transactions?: Record<string, TransactionDefinition>, contractInputs?: ContractInputs): BridgeBundle;
 
-export { type AnyModelContract, AnyOperationDefinition, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchGetExecInput, BatchWriteExecItem, BridgeBundle, type BuiltContracts, CdcEmulator, CdcEmulatorOptions, ChangeEvent, ChangeHandler, ClientManager, type CollectParams, CommandMethodSpec, CommandModelContract, CommandSpec, ConcurrentRecomputeRef, type ConditionExpressionResult, ConditionInput, ConditionSpec, type ContextOwnership, type ContextOwnershipMap, ContextSpec, type ContractBoundaryViolation, type ContractInputs, type ContractMap, type ContractN1Violation, ContractSpec, DDBModel, DefinitionMap, DeleteInput, DynamoDBOperation, DynamoExecutor, type DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, type EmbeddedMetadata, type EntityMetadata, EntityRef, EventLog, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FaultSpec, type FieldMetadata, type FieldOptions, type FilterExpressionResult, type GsiDefinition, type KeyDefinition, type LintResult, type LintRule, Linter, type ListInput, type ListOptions, MAX_TRANSACT_ITEMS, Manifest, MetadataRegistry, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, OperationsDocument, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PrimaryKeyOf, type ProjectionResult, PutInput, QueryMethodSpec, QueryModelContract, type QueryOptions$1 as QueryOptions, QuerySpec, type RelationLimitOptions, type RelationMetadata, type RelationOptions, type RelationTraversalOptions, ReplayOptions, ResolvedKey, SegmentedKey, SelectableOf, ShardId, TableMapping, TransactWriteExecItem, type TransactionDefinition, TransactionItemSpec, type TransactionParamShape, type TransactionRef, TransactionSpec, type TxConditionCheckOptions, type TxForEachInstruction, type TxForEachOptions, type TxInstruction, type TxRecorder, type TxWriteInstruction, type TxWriteOptions, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type WhenComparison, WriteDefinitionOptions, WriteExecOptions, WriteResult, assertBundleSerializable, assertContractBoundaries, assertContractN1Safe, assertJsonSerializable, assertSupportedCondition, belongsTo, binary, boolean, buildBridgeBundle, buildConditionExpression, buildContexts, buildContracts, buildManifest, buildOperations, buildProjection, buildQuerySpec, buildTransactionSpec, buildTransactions, buildUpdateExpression, collectContractBoundaryViolations, collectContractN1Violations, compileFilterExpression, createCdcEmulator, createDefaultLinter, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineTransaction, defineTransactions, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, gsiAmbiguityRule, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, isTransactionRef, list, literal, map, missingGsiRule, model, noScanRule, number, numberSet, plan, queryBoundaryRule, relationDepthRule, requireLimitRule, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, validateDepth, validateGsiAmbiguity, when };
+export { type AnyModelContract, AnyOperationDefinition, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchGetExecInput, BatchWriteExecItem, BridgeBundle, type BuiltContracts, CdcEmulator, CdcEmulatorOptions, ChangeEvent, ChangeHandler, ClientManager, type CollectParams, CommandMethodSpec, CommandModelContract, CommandSpec, ConcurrentRecomputeRef, type ConditionExpressionResult, ConditionInput, ConditionSpec, type ContextOwnership, type ContextOwnershipMap, ContextSpec, type ContractBoundaryViolation, type ContractInputs, type ContractMap, type ContractN1Violation, ContractSpec, DDBModel, DefinitionMap, DeleteInput, DynamoDBOperation, DynamoExecutor, type DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, type EmbeddedMetadata, type EntityMetadata, EntityRef, EventLog, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FaultSpec, type FieldMetadata, type FieldOptions, type FilterExpressionResult, type GsiDefinition, type KeyDefinition, type LintResult, type LintRule, Linter, type ListInput, type ListOptions, MAX_TRANSACT_ITEMS, Manifest, MetadataRegistry, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, OperationsDocument, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PrimaryKeyOf, type ProjectionResult, PutInput, QueryMethodSpec, QueryModelContract, type QueryOptions$1 as QueryOptions, QuerySpec, RawCondition, type RelationLimitOptions, type RelationMetadata, type RelationOptions, type RelationTraversalOptions, ReplayOptions, ResolvedKey, SegmentedKey, SelectableOf, ShardId, TableMapping, TransactWriteExecItem, type TransactionDefinition, TransactionItemSpec, type TransactionParamShape, type TransactionRef, TransactionSpec, type TxConditionCheckOptions, type TxForEachInstruction, type TxForEachOptions, type TxInstruction, type TxRecorder, type TxWriteInstruction, type TxWriteOptions, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type WhenComparison, WriteDefinitionOptions, WriteExecOptions, WriteResult, assertBundleSerializable, assertContractBoundaries, assertContractN1Safe, assertJsonSerializable, assertSupportedCondition, belongsTo, binary, boolean, buildBridgeBundle, buildConditionExpression, buildContexts, buildContracts, buildManifest, buildOperations, buildProjection, buildQuerySpec, buildTransactionSpec, buildTransactions, buildUpdateExpression, collectContractBoundaryViolations, collectContractN1Violations, compileFilterExpression, createCdcEmulator, createDefaultLinter, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineTransaction, defineTransactions, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, gsiAmbiguityRule, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, isTransactionRef, list, literal, map, missingGsiRule, model, noScanRule, number, numberSet, plan, queryBoundaryRule, relationDepthRule, requireLimitRule, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, validateDepth, validateGsiAmbiguity, when };