graphddb 0.2.0 → 0.2.2

package/dist/{chunk-F27INYI2.js → chunk-CXIAECRS.js}

@@ -13,6 +13,7 @@ import {
   buildUpdateInput,
   captureWrite,
   commitTransaction,
+  compileRawCondition,
   createColumnMap,
   execItemKeySignature,
   executeDelete,
@@ -20,14 +21,18 @@ import {
   executeTransaction,
   executeUpdate,
   isColumn,
+  isParam,
+  isRawCondition,
+  param,
   pkTemplate,
   resolveKey,
   resolveModelClass,
   resolveSegmentedKey,
   segmentFieldNames,
   serializeFieldValue,
+  serializeRawCondition,
   skTemplate
-} from "./chunk-347U24SB.js";
+} from "./chunk-3MI43FHU.js";
 
 // src/spec/types.ts
 var SPEC_VERSION = "1.0";
@@ -236,51 +241,6 @@ function getImplicitKeyFields(select, metadata) {
   return [...needed];
 }
 
-// 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/planner/projection.ts
 function buildProjection(select, additionalFields) {
   const paths = [];
@@ -321,32 +281,6 @@ function buildProjection(select, additionalFields) {
   };
 }
 
-// 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;
-}
-
 // src/expression/filter-expression.ts
 var LOGICAL_KEYS = /* @__PURE__ */ new Set(["and", "or", "not"]);
 var OPERATOR_KEYS = /* @__PURE__ */ new Set([
@@ -1916,6 +1850,12 @@ function renderRecord(structure, key, params, context) {
 }
 function renderCondition(condition, key, params, context) {
   if (condition === void 0) return void 0;
+  if (isRawCondition(condition)) {
+    const parts = condition.parts.map(
+      (part) => isColumn(part) ? part : renderLeaf(part, key, params, `${context} condition`)
+    );
+    return { ...condition, parts };
+  }
   if (typeof condition === "object" && condition !== null) {
     const obj = condition;
     if (obj.notExists === true) return { notExists: true };
@@ -2003,14 +1943,14 @@ function renderConditionCheck(check, key, params, contextLabel) {
     modelClass,
     referencedKey
   );
-  const cond2 = buildConditionExpression({ attributeExists: "PK" });
+  const cond = buildConditionExpression({ attributeExists: "PK" });
   const checkInput = {
     TableName,
     Key,
-    ConditionExpression: cond2.expression
+    ConditionExpression: cond.expression
   };
-  if (Object.keys(cond2.names).length > 0) checkInput.ExpressionAttributeNames = cond2.names;
-  if (Object.keys(cond2.values).length > 0) checkInput.ExpressionAttributeValues = cond2.values;
+  if (Object.keys(cond.names).length > 0) checkInput.ExpressionAttributeNames = cond.names;
+  if (Object.keys(cond.values).length > 0) checkInput.ExpressionAttributeValues = cond.values;
   return checkInput;
 }
 var RUNTIME_TOKEN_RE = /\{([^{}]+)\}/g;
@@ -2093,10 +2033,10 @@ function renderUniqueGuardItems(guard, key, params, contextLabel) {
     if (item.type === "Put") {
       const Item = renderTemplateRecord(item.item, key, params, `${contextLabel} guard Put`);
       const put = { TableName: TableMapping.resolve(item.tableName), Item };
-      const cond2 = buildConditionExpression({ attributeNotExists: "PK" });
-      put.ConditionExpression = cond2.expression;
-      if (Object.keys(cond2.names).length > 0) put.ExpressionAttributeNames = cond2.names;
-      if (Object.keys(cond2.values).length > 0) put.ExpressionAttributeValues = cond2.values;
+      const cond = buildConditionExpression({ attributeNotExists: "PK" });
+      put.ConditionExpression = cond.expression;
+      if (Object.keys(cond.names).length > 0) put.ExpressionAttributeNames = cond.names;
+      if (Object.keys(cond.values).length > 0) put.ExpressionAttributeValues = cond.values;
       return { Put: put };
     }
     const Key = renderTemplateRecord(item.keyCondition, key, params, `${contextLabel} guard Delete`);
@@ -2115,10 +2055,10 @@ function renderIdempotencyGuardItems(guard, key, params, contextLabel) {
   return guard.items.map((item) => {
     const Item = renderTemplateRecord(item.item, key, params, `${contextLabel} idempotency Put`);
     const put = { TableName: TableMapping.resolve(item.tableName), Item };
-    const cond2 = buildConditionExpression({ attributeNotExists: "PK" });
-    put.ConditionExpression = cond2.expression;
-    if (Object.keys(cond2.names).length > 0) put.ExpressionAttributeNames = cond2.names;
-    if (Object.keys(cond2.values).length > 0) put.ExpressionAttributeValues = cond2.values;
+    const cond = buildConditionExpression({ attributeNotExists: "PK" });
+    put.ConditionExpression = cond.expression;
+    if (Object.keys(cond.names).length > 0) put.ExpressionAttributeNames = cond.names;
+    if (Object.keys(cond.values).length > 0) put.ExpressionAttributeValues = cond.values;
     return { Put: put };
   });
 }
@@ -3891,17 +3831,24 @@ function describeKey(fragment) {
 }
 
 // src/spec/guard.ts
-function conditionInputToSpec(condition, context, renderLeaf2) {
+function conditionInputToSpec(condition, context, renderLeaf2, renderTreeLeaf, renderRawSlot) {
   if (condition === void 0 || condition === null) return void 0;
+  if (isRawCondition(condition)) {
+    const { expression, names, values } = serializeRawCondition(
+      condition,
+      renderRawSlot
+    );
+    return { kind: "raw", expression, names, values };
+  }
   if (typeof condition !== "object") {
     throw new Error(
-      `${context}: write condition must be an object (\`{ notExists: true }\`, \`{ attributeExists: '<field>' }\`, \`{ attributeNotExists: '<field>' }\`, or field equality).`
+      `${context}: write condition must be an object (\`{ notExists: true }\`, \`{ attributeExists: '<field>' }\`, \`{ attributeNotExists: '<field>' }\`, or a declarative field condition).`
     );
   }
   const obj = condition;
   if (obj.notExists === true) return { kind: "notExists" };
-  if ("attributeExists" in obj) {
-    if (typeof obj.attributeExists !== "string" || obj.attributeExists.length === 0) {
+  if ("attributeExists" in obj && typeof obj.attributeExists === "string") {
+    if (obj.attributeExists.length === 0) {
       throw new Error(
         `${context}: \`attributeExists\` must name a non-empty attribute field.`
       );
@@ -3916,12 +3863,122 @@ function conditionInputToSpec(condition, context, renderLeaf2) {
     }
     return { kind: "attributeNotExists", field: obj.attributeNotExists };
   }
+  if (usesOperatorTree(obj)) {
+    const leaf = renderTreeLeaf ?? ((value, name) => defaultTreeLeaf(value, name, context));
+    return { kind: "expr", declarative: buildTree(obj, context, leaf) };
+  }
   const fields = {};
   for (const key of Object.keys(obj).sort()) {
     fields[key] = renderLeaf2(key, obj[key]);
   }
   return { kind: "equals", fields };
 }
+function assertNotNestedRaw(sub, context) {
+  if (isRawCondition(sub)) {
+    throw new Error(
+      `${context}: a raw \`cond\` write condition may be used as a whole condition, but not nested inside an \`and\` / \`or\` / \`not\` group of a serializable (public-contract / Python-bridge) command. Move the \`cond\` to the top level, or express the group declaratively.`
+    );
+  }
+}
+var LOGICAL_KEYS2 = /* @__PURE__ */ new Set(["and", "or", "not"]);
+var OPERATOR_KEYS2 = /* @__PURE__ */ new Set([
+  "eq",
+  "ne",
+  "gt",
+  "ge",
+  "lt",
+  "le",
+  "between",
+  "in",
+  "beginsWith",
+  "contains",
+  "notContains",
+  "attributeExists",
+  "attributeType",
+  "size"
+]);
+function isOperatorObject2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 0) return false;
+  return keys.every((k) => OPERATOR_KEYS2.has(k));
+}
+function usesOperatorTree(obj) {
+  for (const [key, value] of Object.entries(obj)) {
+    if (LOGICAL_KEYS2.has(key)) return true;
+    if (isOperatorObject2(value)) return true;
+  }
+  return false;
+}
+function defaultTreeLeaf(value, name, context) {
+  void name;
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  throw new Error(
+    `${context}: condition operand must be a concrete literal or a param; got ${typeof value}.`
+  );
+}
+function conditionParamName(field, op, index) {
+  if (op === "between") return `${field}_${index === 0 ? "lo" : "hi"}`;
+  if (op === "in") return `${field}_${index ?? 0}`;
+  if (op === "size") return `${field}_size`;
+  return field;
+}
+function buildTree(obj, context, renderTreeLeaf) {
+  const out = {};
+  for (const key of Object.keys(obj).sort()) {
+    const value = obj[key];
+    if (value === void 0) continue;
+    if (key === "and" || key === "or") {
+      out[key] = value.map((sub) => {
+        assertNotNestedRaw(sub, context);
+        return buildTree(sub, context, renderTreeLeaf);
+      });
+      continue;
+    }
+    if (key === "not") {
+      assertNotNestedRaw(value, context);
+      out[key] = buildTree(
+        value,
+        context,
+        renderTreeLeaf
+      );
+      continue;
+    }
+    if (!isOperatorObject2(value)) {
+      out[key] = { eq: renderTreeLeaf(value, conditionParamName(key, "eq")) };
+      continue;
+    }
+    const ops = value;
+    const rendered = {};
+    for (const op of Object.keys(ops).sort()) {
+      const opVal = ops[op];
+      if (op === "between") {
+        const [lo, hi] = opVal;
+        rendered[op] = [
+          renderTreeLeaf(lo, conditionParamName(key, op, 0)),
+          renderTreeLeaf(hi, conditionParamName(key, op, 1))
+        ];
+      } else if (op === "in") {
+        rendered[op] = opVal.map(
+          (v, i) => renderTreeLeaf(v, conditionParamName(key, op, i))
+        );
+      } else if (op === "attributeExists") {
+        rendered[op] = opVal;
+      } else if (op === "attributeType") {
+        rendered[op] = String(opVal);
+      } else {
+        rendered[op] = renderTreeLeaf(opVal, conditionParamName(key, op));
+      }
+    }
+    out[key] = rendered;
+  }
+  return out;
+}
 function assertSupportedCondition(commandName, condition) {
   if (condition.kind === "notExists") return;
   if (condition.kind === "attributeExists" || condition.kind === "attributeNotExists") {
@@ -3948,8 +4005,25 @@ function assertSupportedCondition(commandName, condition) {
     }
     return;
   }
+  if (condition.kind === "raw") {
+    if (typeof condition.expression !== "string" || condition.expression.length === 0) {
+      throw new Error(
+        `Command '${commandName}' has an empty raw \`cond\` write condition.`
+      );
+    }
+    return;
+  }
+  if (condition.kind === "expr") {
+    const tree = condition.declarative;
+    if (!tree || Object.keys(tree).length === 0) {
+      throw new Error(
+        `Command '${commandName}' has an empty declarative write condition.`
+      );
+    }
+    return;
+  }
   throw new Error(
-    `Command '${commandName}' has an unsupported write condition. The Python bridge supports '{ notExists }' or field equality only.`
+    `Command '${commandName}' has an unsupported write condition.`
   );
 }
 function assertJsonSerializable(value, path = "$") {
@@ -4498,6 +4572,17 @@ function leafTemplate(value, context) {
     `defineTransaction: ${context} must be a field reference (from \`p\` or a forEach element) or a concrete literal; got ${typeof value}.`
   );
 }
+function conditionTreeLeaf(value, name, context) {
+  void name;
+  if (isTransactionRef(value)) return { $param: tokenName(value.token) };
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  throw new Error(
+    `defineTransaction: ${context} condition operand must be a field reference (from \`p\` or a forEach element) or a concrete literal; got ${typeof value}.`
+  );
+}
 function templateRecord2(structure, context) {
   const out = {};
   for (const field of Object.keys(structure).sort()) {
@@ -4541,7 +4626,12 @@ function conditionSpec(condition, commandName) {
   const spec = conditionInputToSpec(
     condition,
     commandName,
-    (field, value) => leafTemplate(value, `condition field '${field}'`)
+    (field, value) => leafTemplate(value, `condition field '${field}'`),
+    (value, name) => conditionTreeLeaf(value, name, commandName),
+    // A raw `cond` value slot in a transaction is a field reference
+    // (`p.*` / forEach element) → a `{ $param }` marker carrying its token name;
+    // a concrete literal falls through to the default renderer (issue #114-B).
+    (part) => isTransactionRef(part) ? { $param: tokenName(part.token) } : void 0
   );
   if (spec) assertSupportedCondition(commandName, spec);
   return spec;
@@ -4593,12 +4683,51 @@ function buildWriteItem(instr, forEachSource, txName) {
       )
     };
   }
+  const changes = templateRecord2(instr.changes ?? {}, `${txName} update changes`);
+  injectTransactionGsiRederive(
+    metadata,
+    instr.key ?? {},
+    instr.changes ?? {},
+    changes,
+    `${txName} update on '${entity}'`
+  );
   return {
     ...base,
     keyCondition: keyConditionTemplate2(metadata, instr.key ?? {}, `${txName} update`),
-    changes: templateRecord2(instr.changes ?? {}, `${txName} update changes`)
+    changes
   };
 }
+function injectTransactionGsiRederive(metadata, keyStructure, changeStructure, changes, context) {
+  if (metadata.gsiDefinitions.length === 0) return;
+  const changedFields = new Set(Object.keys(changeStructure));
+  const nameByField = /* @__PURE__ */ new Map();
+  for (const [field, value] of Object.entries(keyStructure)) {
+    if (isTransactionRef(value)) nameByField.set(field, tokenName(value.token));
+  }
+  for (const [field, value] of Object.entries(changeStructure)) {
+    if (isTransactionRef(value)) nameByField.set(field, tokenName(value.token));
+  }
+  const available = new Set(nameByField.keys());
+  for (const gsi of metadata.gsiDefinitions) {
+    if (!gsi.inputFieldNames.some((f) => changedFields.has(f))) continue;
+    const missing = gsi.inputFieldNames.filter((f) => !available.has(f));
+    if (missing.length > 0) {
+      const changed = gsi.inputFieldNames.filter((f) => changedFields.has(f));
+      throw new Error(
+        `defineTransaction: ${context}: updating ${changed.map((f) => `'${f}'`).join(", ")} affects index '${gsi.indexName}' (also depends on ${missing.map((f) => `'${f}'`).join(", ")}); add ${missing.length > 1 ? "them" : "it"} to the update key or changes.`
+      );
+    }
+    const present = new Set(gsi.inputFieldNames);
+    const { pk, sk } = evaluateKey(
+      gsi.segmented,
+      "param",
+      present,
+      (f) => nameByField.get(f) ?? f
+    );
+    changes[`${gsi.indexName}PK`] = pk;
+    if (sk !== void 0) changes[`${gsi.indexName}SK`] = sk;
+  }
+}
 function buildTransactionSpec(txName, def) {
   const items = [];
   let hasForEach = false;
@@ -5092,9 +5221,32 @@ function extractCondition(def) {
   return conditionInputToSpec(
     def.condition,
     `Command on '${def.entity.name}'`,
-    (field, value) => templateLeaf(field, value)
+    (field, value) => templateLeaf(field, value),
+    (value, name) => conditionTreeLeaf2(value, name),
+    // A raw `cond` value slot (issue #114-B): a contract param / key ref carries
+    // its own name; a plain `param.*` falls through to the positional default.
+    (part) => {
+      if (isContractParamRef(part)) return { $param: tokenName2(part.token) };
+      if (isContractKeyFieldRef(part)) return { $param: part.field };
+      return void 0;
+    }
   );
 }
+function conditionTreeLeaf2(value, name) {
+  if (isContractParamRef(value)) return { $param: tokenName2(value.token) };
+  if (isContractKeyFieldRef(value)) return { $param: value.field };
+  if (isParam(value)) return { $param: name };
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  throw new Error(
+    `A declarative write-condition operand must be a concrete literal or a param reference; got ${typeof value}.`
+  );
+}
+function tokenName2(token) {
+  return token.startsWith("{") && token.endsWith("}") ? token.slice(1, -1) : token;
+}
 function buildQuerySpec(def) {
   const operations = buildReadOperations(def);
   const executionPlan = deriveExecutionPlan(operations.map((op) => op.resultPath));
@@ -5252,6 +5404,7 @@ function convertLeaf(leaf, bindField, place, context) {
   );
 }
 function convertCondition(condition, place, context) {
+  if (isRawCondition(condition)) return condition;
   if (typeof condition === "object" && condition !== null) {
     const obj = condition;
     if (obj.notExists === true) return { notExists: true };
@@ -5414,8 +5567,32 @@ function toElementRecord(record, keyParams) {
   return out;
 }
 function toElementCondition(condition, keyParams) {
-  if (condition.kind !== "equals") return condition;
-  return { kind: "equals", fields: toElementRecord(condition.fields, keyParams) };
+  if (condition.kind === "equals") {
+    return { kind: "equals", fields: toElementRecord(condition.fields, keyParams) };
+  }
+  if (condition.kind === "expr") {
+    return { kind: "expr", declarative: toElementTree(condition.declarative, keyParams) };
+  }
+  if (condition.kind === "raw") {
+    return {
+      kind: "raw",
+      expression: condition.expression,
+      names: condition.names,
+      values: toElementTree(condition.values, keyParams)
+    };
+  }
+  return condition;
+}
+function toElementTree(node, keyParams) {
+  if (Array.isArray(node)) return node.map((n) => toElementTree(n, keyParams));
+  if (node === null || typeof node !== "object") return node;
+  const obj = node;
+  if (typeof obj.$param === "string" && !obj.$param.startsWith("item.")) {
+    return keyParams.has(obj.$param) ? { $param: `item.${obj.$param}` } : obj;
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) out[k] = toElementTree(v, keyParams);
+  return out;
 }
 function synthesizeBatchTransaction(commandSpec, op) {
   const keyParams = new Set(keyParamNames(op));
@@ -5948,10 +6125,7 @@ export {
   normalizeSelectSpec,
   detectRelationFields,
   getImplicitKeyFields,
-  param,
-  isParam,
   buildProjection,
-  cond,
   compileFilterExpression,
   evaluateFilter,
   plan,
@@ -6013,6 +6187,7 @@ export {
   publicQueryModel,
   publicCommandModel,
   isPlannedCommandMethod,
+  conditionParamName,
   assertSupportedCondition,
   assertJsonSerializable,
   assertBundleSerializable,

package/dist/cli.js

@@ -2,10 +2,10 @@
 import {
   buildBridgeBundle,
   normalizeSelectSpec
-} from "./chunk-F27INYI2.js";
+} from "./chunk-CXIAECRS.js";
 import {
   MetadataRegistry
-} from "./chunk-347U24SB.js";
+} from "./chunk-3MI43FHU.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-SKxZQbQO.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-SKxZQbQO.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 };