dynamodb-expression-builder 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1908 @@
+
+//#region src/types.ts
+/** The set-typed tags, which carry members in `values` rather than `value`. */
+const SET_TYPES = [
+	"SS",
+	"NS",
+	"BS"
+];
+function isSetType(type) {
+	return type === "SS" || type === "NS" || type === "BS";
+}
+/**
+* The scalar element type of a set tag (SS→S, NS→N, BS→B); identity for every
+* scalar. `contains(path, operand)` takes a SCALAR operand even when `path` is a
+* set (it tests membership), so the set-typed tag must marshal its ELEMENT type
+* there — never `{SS:[…]}`, which DynamoDB rejects.
+*/
+function elementType(type) {
+	switch (type) {
+		case "SS": return "S";
+		case "NS": return "N";
+		case "BS": return "B";
+		default: return type;
+	}
+}
+/**
+* Build a {@link TypedValue} from a tag + raw entry. Set types take an explicit
+* member array (falling back to the single `value` as one member); scalars take
+* the string; NULL ignores the payload.
+*/
+function makeTypedValue(type, value, values) {
+	if (isSetType(type)) return {
+		type,
+		value: "",
+		values: values ?? (value ? [value] : [])
+	};
+	if (type === "NULL") return {
+		type,
+		value: ""
+	};
+	return {
+		type,
+		value
+	};
+}
+
+//#endregion
+//#region src/operators.ts
+const ALL_SCAN_TYPES = [
+	"S",
+	"N",
+	"B",
+	"SS",
+	"NS",
+	"BS",
+	"BOOL",
+	"NULL",
+	"L",
+	"M"
+];
+const COLLECTION_TYPES = [
+	"SS",
+	"NS",
+	"BS",
+	"L",
+	"M"
+];
+const FILTER_OPERATORS = [
+	{
+		value: "=",
+		label: "Equals (=)",
+		symbol: "=",
+		wireForm: "EQ",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: [
+			"S",
+			"N",
+			"B"
+		],
+		scanAllowedTypes: ALL_SCAN_TYPES
+	},
+	{
+		value: "<>",
+		label: "Not Equals (≠)",
+		symbol: "≠",
+		wireForm: "NE",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: [],
+		scanAllowedTypes: ALL_SCAN_TYPES
+	},
+	{
+		value: "<",
+		label: "Less Than (<)",
+		symbol: "<",
+		wireForm: "LT",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: ["N"],
+		scanAllowedTypes: ["N"]
+	},
+	{
+		value: "<=",
+		label: "Less Than or Equal (≤)",
+		symbol: "≤",
+		wireForm: "LE",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: ["N"],
+		scanAllowedTypes: ["N"]
+	},
+	{
+		value: ">",
+		label: "Greater Than (>)",
+		symbol: ">",
+		wireForm: "GT",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: ["N"],
+		scanAllowedTypes: ["N"]
+	},
+	{
+		value: ">=",
+		label: "Greater Than or Equal (≥)",
+		symbol: "≥",
+		wireForm: "GE",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: ["N"],
+		scanAllowedTypes: ["N"]
+	},
+	{
+		value: "contains",
+		label: "Contains",
+		symbol: "∋",
+		wireForm: "CONTAINS",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: [],
+		scanAllowedTypes: [
+			"S",
+			"B",
+			"SS",
+			"NS",
+			"BS",
+			"L"
+		]
+	},
+	{
+		value: "begins_with",
+		label: "Begins With",
+		symbol: "^",
+		wireForm: "BEGINS_WITH",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: ["S", "B"],
+		scanAllowedTypes: ["S", "B"]
+	},
+	{
+		value: "between",
+		label: "Between",
+		symbol: "↔",
+		wireForm: "BETWEEN",
+		requiresValue: true,
+		requiresValue2: true,
+		typeOptional: false,
+		keyAllowedTypes: ["N"],
+		scanAllowedTypes: ["N"]
+	},
+	{
+		value: "in",
+		label: "In",
+		symbol: "∈",
+		wireForm: "IN",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: [],
+		scanAllowedTypes: ["S", "N"]
+	},
+	{
+		value: "exists",
+		label: "Attribute Exists",
+		symbol: "∃",
+		wireForm: "EXISTS",
+		requiresValue: false,
+		requiresValue2: false,
+		typeOptional: true,
+		keyAllowedTypes: [],
+		scanAllowedTypes: ALL_SCAN_TYPES
+	},
+	{
+		value: "not_exists",
+		label: "Attribute Not Exists",
+		symbol: "∄",
+		wireForm: "NOT_EXISTS",
+		requiresValue: false,
+		requiresValue2: false,
+		typeOptional: true,
+		keyAllowedTypes: [],
+		scanAllowedTypes: ALL_SCAN_TYPES
+	},
+	{
+		value: "size_eq",
+		label: "Size Equals",
+		symbol: "size =",
+		wireForm: "SIZE_EQ",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: true,
+		keyAllowedTypes: [],
+		scanAllowedTypes: COLLECTION_TYPES
+	},
+	{
+		value: "size_ne",
+		label: "Size Not Equals",
+		symbol: "size ≠",
+		wireForm: "SIZE_NE",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: true,
+		keyAllowedTypes: [],
+		scanAllowedTypes: COLLECTION_TYPES
+	},
+	{
+		value: "size_lt",
+		label: "Size Less Than",
+		symbol: "size <",
+		wireForm: "SIZE_LT",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: true,
+		keyAllowedTypes: [],
+		scanAllowedTypes: COLLECTION_TYPES
+	},
+	{
+		value: "size_le",
+		label: "Size Less Than or Equal",
+		symbol: "size ≤",
+		wireForm: "SIZE_LE",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: true,
+		keyAllowedTypes: [],
+		scanAllowedTypes: COLLECTION_TYPES
+	},
+	{
+		value: "size_gt",
+		label: "Size Greater Than",
+		symbol: "size >",
+		wireForm: "SIZE_GT",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: true,
+		keyAllowedTypes: [],
+		scanAllowedTypes: COLLECTION_TYPES
+	},
+	{
+		value: "size_ge",
+		label: "Size Greater Than or Equal",
+		symbol: "size ≥",
+		wireForm: "SIZE_GE",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: true,
+		keyAllowedTypes: [],
+		scanAllowedTypes: COLLECTION_TYPES
+	},
+	{
+		value: "type_eq",
+		label: "Type Equals",
+		symbol: "type =",
+		wireForm: "TYPE_EQ",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: [],
+		scanAllowedTypes: ALL_SCAN_TYPES
+	},
+	{
+		value: "type_ne",
+		label: "Type Not Equals",
+		symbol: "type ≠",
+		wireForm: "TYPE_NE",
+		requiresValue: true,
+		requiresValue2: false,
+		typeOptional: false,
+		keyAllowedTypes: [],
+		scanAllowedTypes: ALL_SCAN_TYPES
+	}
+];
+/**
+* O(1) registry lookup. Loose-keyed (`Record<string, OperatorDef>`) so boundary
+* callers must guard `if (!def)` — the runtime value is `undefined` for unknown
+* keys.
+*/
+const OPERATOR_BY_VALUE = Object.fromEntries(FILTER_OPERATORS.map((op) => [op.value, op]));
+/** Key-eligible operators (KeyConditionExpression compatible). */
+const KEY_OPERATORS = FILTER_OPERATORS.filter((op) => op.keyAllowedTypes.length > 0);
+/**
+* Operators applicable to a scan value of the given type. Undefined type → full
+* list. Filters/conditions use this.
+*/
+function getCompatibleFilterOperators(type) {
+	if (!type) return FILTER_OPERATORS;
+	return FILTER_OPERATORS.filter((op) => op.scanAllowedTypes.includes(type));
+}
+/**
+* Key-eligible operators compatible with the given key type. Undefined → full
+* key list. Range-key UI uses this (type-gated: N gets `<`/`between`, S/B get
+* `begins_with`, all keys get `=`).
+*/
+function getCompatibleComparisonOperators(type) {
+	if (!type) return KEY_OPERATORS;
+	return KEY_OPERATORS.filter((op) => op.keyAllowedTypes.includes(type));
+}
+
+//#endregion
+//#region src/filter-expressions.ts
+/**
+* Compile a list of predicate rows into one `… AND …` expression plus the
+* fresh names/typedValues maps it references. Returns null for an empty list.
+* Callers (buildRequest) merge the maps; this function never mutates shared
+* state.
+*/
+function buildFilterExpressions(rows, prefix) {
+	if (rows.length === 0) return null;
+	const names = {};
+	const typedValues = {};
+	return {
+		expression: rows.map((row, index) => buildOne(row, index, prefix, names, typedValues)).join(" AND "),
+		names,
+		typedValues
+	};
+}
+function buildOne(row, index, prefix, names, typedValues) {
+	const wire = OPERATOR_BY_VALUE[row.operator].wireForm;
+	const nameRef = `#${prefix}${index}`;
+	names[nameRef] = row.field;
+	const valueRef = `:${prefix}Value${index}`;
+	const valueRef2 = `:${prefix}Value${index}_2`;
+	switch (wire) {
+		case "EQ":
+			typedValues[valueRef] = single$1(row);
+			return `${nameRef} = ${valueRef}`;
+		case "NE":
+			typedValues[valueRef] = single$1(row);
+			return `${nameRef} <> ${valueRef}`;
+		case "GT":
+			typedValues[valueRef] = single$1(row);
+			return `${nameRef} > ${valueRef}`;
+		case "GE":
+			typedValues[valueRef] = single$1(row);
+			return `${nameRef} >= ${valueRef}`;
+		case "LT":
+			typedValues[valueRef] = single$1(row);
+			return `${nameRef} < ${valueRef}`;
+		case "LE":
+			typedValues[valueRef] = single$1(row);
+			return `${nameRef} <= ${valueRef}`;
+		case "CONTAINS":
+			typedValues[valueRef] = makeTypedValue(elementType(row.type), row.value);
+			return `contains(${nameRef}, ${valueRef})`;
+		case "BEGINS_WITH":
+			typedValues[valueRef] = single$1(row);
+			return `begins_with(${nameRef}, ${valueRef})`;
+		case "BETWEEN":
+			typedValues[valueRef] = makeTypedValue(row.type, row.value);
+			typedValues[valueRef2] = makeTypedValue(row.type, row.value2 ?? "");
+			return `${nameRef} BETWEEN ${valueRef} AND ${valueRef2}`;
+		case "IN": {
+			const members = row.values ?? (row.value ? [row.value] : []);
+			if (members.length === 0) throw new Error(`IN on "${row.field}" requires at least one value`);
+			return `${nameRef} IN (${members.map((member, i) => {
+				const ref = `:${prefix}Value${index}_${i}`;
+				typedValues[ref] = makeTypedValue(row.type, member);
+				return ref;
+			}).join(", ")})`;
+		}
+		case "EXISTS": return `attribute_exists(${nameRef})`;
+		case "NOT_EXISTS": return `attribute_not_exists(${nameRef})`;
+		case "SIZE_EQ":
+			typedValues[valueRef] = single$1(row);
+			return `size(${nameRef}) = ${valueRef}`;
+		case "SIZE_NE":
+			typedValues[valueRef] = single$1(row);
+			return `size(${nameRef}) <> ${valueRef}`;
+		case "SIZE_LT":
+			typedValues[valueRef] = single$1(row);
+			return `size(${nameRef}) < ${valueRef}`;
+		case "SIZE_LE":
+			typedValues[valueRef] = single$1(row);
+			return `size(${nameRef}) <= ${valueRef}`;
+		case "SIZE_GT":
+			typedValues[valueRef] = single$1(row);
+			return `size(${nameRef}) > ${valueRef}`;
+		case "SIZE_GE":
+			typedValues[valueRef] = single$1(row);
+			return `size(${nameRef}) >= ${valueRef}`;
+		case "TYPE_EQ":
+			typedValues[valueRef] = single$1(row);
+			return `attribute_type(${nameRef}, ${valueRef})`;
+		case "TYPE_NE":
+			typedValues[valueRef] = single$1(row);
+			return `NOT attribute_type(${nameRef}, ${valueRef})`;
+	}
+}
+/** Capture the row's single RHS value as a typed value (set- or scalar-aware). */
+function single$1(row) {
+	return makeTypedValue(row.type, row.value, row.values);
+}
+
+//#endregion
+//#region src/key-command.ts
+/**
+* Build a Query KeyConditionExpression from a hash key (always EQ) plus an
+* optional range-key condition. Captures value types.
+*/
+function buildKeyConditionExpression(hashKey, rangeKey) {
+	const names = { "#hashKey": hashKey.field };
+	const typedValues = { ":hashKeyValue": makeTypedValue(hashKey.type, hashKey.value) };
+	let expression = "#hashKey = :hashKeyValue";
+	if (rangeKey) {
+		names["#rangeKey"] = rangeKey.field;
+		const wire = OPERATOR_BY_VALUE[rangeKey.operator].wireForm;
+		if (wire === "BETWEEN") {
+			typedValues[":rangeKeyValue"] = makeTypedValue(rangeKey.type, rangeKey.value);
+			typedValues[":rangeKeyValue2"] = makeTypedValue(rangeKey.type, rangeKey.value2 ?? "");
+			expression += " AND #rangeKey BETWEEN :rangeKeyValue AND :rangeKeyValue2";
+		} else if (wire === "BEGINS_WITH") {
+			typedValues[":rangeKeyValue"] = makeTypedValue(rangeKey.type, rangeKey.value);
+			expression += " AND begins_with(#rangeKey, :rangeKeyValue)";
+		} else {
+			const symbol = SYMBOL_BY_WIRE[wire];
+			if (!symbol) throw new Error(`Operator ${rangeKey.operator} is not key-eligible`);
+			typedValues[":rangeKeyValue"] = makeTypedValue(rangeKey.type, rangeKey.value);
+			expression += ` AND #rangeKey ${symbol} :rangeKeyValue`;
+		}
+	}
+	return {
+		expression,
+		names,
+		typedValues
+	};
+}
+/**
+* Comparison symbols for the simple key operators. Partial on purpose: a
+* range-key row carries an `OperatorValue` from the full set, so a non-key
+* operator (e.g. `contains`) can reach here at runtime — the lookup returns
+* undefined and the caller throws rather than emitting a malformed expression.
+*/
+const SYMBOL_BY_WIRE = {
+	EQ: "=",
+	GT: ">",
+	GE: ">=",
+	LT: "<",
+	LE: "<="
+};
+/**
+* Build the plain typed Key map (GetItem/Update/Delete) — real attribute names
+* mapped to typed values, no expression placeholders.
+*/
+function buildKeyMap(keys) {
+	const map = {};
+	for (const k of keys) map[k.field] = makeTypedValue(k.type, k.value);
+	return map;
+}
+
+//#endregion
+//#region src/build-update-expression.ts
+/** DynamoDB clause order. SET, REMOVE, ADD, DELETE — each emitted at most once. */
+const CLAUSE_ORDER = [
+	"SET",
+	"REMOVE",
+	"ADD",
+	"DELETE"
+];
+/**
+* Compile update actions into one UpdateExpression. Returns null for an empty
+* list. Callers (buildRequest) merge the returned maps; this never mutates
+* shared state. Actions are grouped by kind into the canonical
+* `SET … REMOVE … ADD … DELETE …` order while preserving each action's input
+* order within its clause.
+*/
+function buildUpdateExpression(actions) {
+	if (actions.length === 0) return null;
+	const names = {};
+	const typedValues = {};
+	const clauses = {
+		SET: [],
+		REMOVE: [],
+		ADD: [],
+		DELETE: []
+	};
+	actions.forEach((action, index) => {
+		const nameRef = `#upd${index}`;
+		names[nameRef] = action.field;
+		const valueRef = `:updValue${index}`;
+		switch (action.kind) {
+			case "SET":
+				clauses.SET.push(compileSet(action, nameRef, valueRef, typedValues));
+				break;
+			case "REMOVE":
+				clauses.REMOVE.push(action.index === void 0 ? nameRef : `${nameRef}[${action.index}]`);
+				break;
+			case "ADD":
+				typedValues[valueRef] = requireValue(action);
+				clauses.ADD.push(`${nameRef} ${valueRef}`);
+				break;
+			case "DELETE":
+				typedValues[valueRef] = requireValue(action);
+				clauses.DELETE.push(`${nameRef} ${valueRef}`);
+				break;
+		}
+	});
+	return {
+		expression: CLAUSE_ORDER.filter((kind) => clauses[kind].length > 0).map((kind) => `${kind} ${clauses[kind].join(", ")}`).join(" "),
+		names,
+		typedValues
+	};
+}
+/** Compile one SET action's RHS per its idiom, capturing the typed value. */
+function compileSet(action, nameRef, valueRef, typedValues) {
+	typedValues[valueRef] = requireValue(action);
+	switch (action.setOp ?? "assign") {
+		case "assign": return `${nameRef} = ${valueRef}`;
+		case "if_not_exists": return `${nameRef} = if_not_exists(${nameRef}, ${valueRef})`;
+		case "add": return `${nameRef} = ${nameRef} + ${valueRef}`;
+		case "subtract": return `${nameRef} = ${nameRef} - ${valueRef}`;
+		case "list_append": return `${nameRef} = list_append(${nameRef}, ${valueRef})`;
+		case "list_prepend": return `${nameRef} = list_append(${valueRef}, ${nameRef})`;
+	}
+}
+/** Fail loud: a value-bearing action (SET/ADD/DELETE) must carry a value. */
+function requireValue(action) {
+	if (!action.value) throw new Error(`Update action ${action.kind} on "${action.field}" requires a value`);
+	return action.value;
+}
+
+//#endregion
+//#region src/build-request.ts
+/**
+* Assemble a {@link CanonicalRequest} from a builder config. Pure: reads only the
+* config sub-parts the operation uses, merges the sub-builders' maps, and omits
+* any map that ended up empty. Throws (fail loud) when a required part is missing
+* (a Query without a hash key) rather than emitting a malformed request.
+*/
+function buildRequest(config) {
+	const names = {};
+	const typedValues = {};
+	const request = {
+		operation: config.operation,
+		tableName: config.tableName,
+		config
+	};
+	if (config.indexName) request.indexName = config.indexName;
+	switch (config.operation) {
+		case "GetItem":
+			assignKey(request, config);
+			applyProjection(request, config, names);
+			if (config.consistentRead) request.consistentRead = true;
+			break;
+		case "Query": {
+			if (!config.hashKey) throw new Error("Query requires a hash key");
+			const kc = buildKeyConditionExpression(config.hashKey, config.rangeKey);
+			request.keyConditionExpression = kc.expression;
+			Object.assign(names, kc.names);
+			Object.assign(typedValues, kc.typedValues);
+			applyFilter(request, config, names, typedValues);
+			applyProjection(request, config, names);
+			applyReadOptions(request, config);
+			if (config.scanIndexForward === false) request.scanIndexForward = false;
+			break;
+		}
+		case "Scan":
+			applyFilter(request, config, names, typedValues);
+			applyProjection(request, config, names);
+			applyReadOptions(request, config);
+			break;
+		case "Update": {
+			assignKey(request, config);
+			const update = buildUpdateExpression(config.updates ?? []);
+			if (update) {
+				request.updateExpression = update.expression;
+				Object.assign(names, update.names);
+				Object.assign(typedValues, update.typedValues);
+			}
+			applyCondition(request, config, names, typedValues);
+			break;
+		}
+		case "Put": {
+			const item = buildItemMap(config.item ?? []);
+			if (Object.keys(item).length > 0) request.item = item;
+			applyCondition(request, config, names, typedValues);
+			break;
+		}
+		case "Delete":
+			assignKey(request, config);
+			applyCondition(request, config, names, typedValues);
+			break;
+	}
+	if (Object.keys(names).length > 0) request.names = names;
+	if (Object.keys(typedValues).length > 0) request.typedValues = typedValues;
+	assertNoEmptySets(request);
+	return request;
+}
+/**
+* An empty set (`{SS:[]}`/`{NS:[]}`/`{BS:[]}`) is rejected by DynamoDB at runtime.
+* Catch it at build time — mirroring the empty-`IN` guard in filter-expressions —
+* so the tool never hands out a snippet that fails when run. PartiQL is emitted
+* from the same request (which `emit()` builds first), so this covers every format.
+*/
+function assertNoEmptySets(request) {
+	for (const map of [
+		request.key,
+		request.item,
+		request.typedValues,
+		request.exclusiveStartKey
+	]) {
+		if (!map) continue;
+		for (const tv of Object.values(map)) if (isSetType(tv.type) && (tv.values?.length ?? 0) === 0) throw new Error("a set value (SS/NS/BS) requires at least one member");
+	}
+}
+/**
+* Attach the Query/Scan request-level read options: `Limit` (validated — a
+* non-positive/non-integer limit fails loud rather than emitting `Limit: 0`),
+* `ConsistentRead` (only `true` carried), and `ExclusiveStartKey` (typed key
+* map, omitted when empty). `ScanIndexForward` is handled at the Query call
+* site — it's Query-only.
+*/
+function applyReadOptions(request, config) {
+	if (config.limit !== void 0) {
+		if (!Number.isInteger(config.limit) || config.limit <= 0) throw new Error("Limit must be a positive integer");
+		request.limit = config.limit;
+	}
+	if (config.consistentRead) request.consistentRead = true;
+	const startKey = buildKeyMap(config.exclusiveStartKey ?? []);
+	if (Object.keys(startKey).length > 0) request.exclusiveStartKey = startKey;
+}
+/** Attach the typed Key map (GetItem/Update/Delete), omitting it when empty. */
+function assignKey(request, config) {
+	const key = buildKeyMap(config.key ?? []);
+	if (Object.keys(key).length > 0) request.key = key;
+}
+/** Compile filters into a FilterExpression + merge its maps (Query/Scan). */
+function applyFilter(request, config, names, typedValues) {
+	const filter = buildFilterExpressions(config.filters ?? [], "filter");
+	if (!filter) return;
+	request.filterExpression = filter.expression;
+	Object.assign(names, filter.names);
+	Object.assign(typedValues, filter.typedValues);
+}
+/** Compile conditions into a ConditionExpression + merge its maps (write ops). */
+function applyCondition(request, config, names, typedValues) {
+	const condition = buildFilterExpressions(config.conditions ?? [], "cond");
+	if (!condition) return;
+	request.conditionExpression = condition.expression;
+	Object.assign(names, condition.names);
+	Object.assign(typedValues, condition.typedValues);
+}
+/**
+* Build a `#`-aliased ProjectionExpression (read ops only). Each projected
+* attribute gets a fresh `#proj{i}` alias so reserved words are always safe and
+* the aliases never collide with key/filter prefixes.
+*/
+function applyProjection(request, config, names) {
+	const attrs = config.projection;
+	if (!attrs || attrs.length === 0) return;
+	request.projectionExpression = attrs.map((attr, index) => {
+		const ref = `#proj${index}`;
+		names[ref] = attr;
+		return ref;
+	}).join(", ");
+}
+/** Build the typed Put item map — real attribute names → typed values. */
+function buildItemMap(items) {
+	const map = {};
+	for (const attr of items) map[attr.field] = makeTypedValue(attr.type, attr.value, attr.values);
+	return map;
+}
+
+//#endregion
+//#region src/emit/marshal.ts
+/** Build an AttributeValue from a value's type tag (not its runtime type). */
+function typedValueToAv(tv) {
+	switch (tv.type) {
+		case "S": return { S: tv.value };
+		case "N": return { N: tv.value };
+		case "B": return { B: tv.value };
+		case "BOOL": return { BOOL: tv.value === "true" };
+		case "SS": return { SS: tv.values ?? [] };
+		case "NS": return { NS: tv.values ?? [] };
+		case "BS": return { BS: tv.values ?? [] };
+		case "NULL": return { NULL: true };
+	}
+}
+/** Marshal a whole placeholder/attr map (`:v`→typed, or name→typed) to AVs. */
+function typedMapToAvMap(map) {
+	const out = {};
+	for (const [key, tv] of Object.entries(map)) out[key] = typedValueToAv(tv);
+	return out;
+}
+/**
+* Does this request carry any binary (`B`/`BS`) value? The SDK v3 / boto3
+* emitters use this to decide whether to emit binary-decoding (a `Uint8Array`
+* expression / an `import base64`).
+*/
+function hasBinaryValue(request) {
+	return [
+		request.key,
+		request.item,
+		request.typedValues,
+		request.exclusiveStartKey
+	].some((map) => map !== void 0 && Object.values(map).some((tv) => tv.type === "B" || tv.type === "BS"));
+}
+
+//#endregion
+//#region src/emit/sdk-v3.ts
+/** Operation → the `@aws-sdk/client-dynamodb` command class name. */
+const COMMAND_BY_OP = {
+	GetItem: "GetItemCommand",
+	Query: "QueryCommand",
+	Scan: "ScanCommand",
+	Update: "UpdateItemCommand",
+	Put: "PutItemCommand",
+	Delete: "DeleteItemCommand"
+};
+/** Build the command params object (key order matches typical SDK usage). */
+function buildSdkV3Params(request) {
+	const p = { TableName: request.tableName };
+	if (request.indexName) p.IndexName = request.indexName;
+	if (request.key) p.Key = typedMapToAvMap(request.key);
+	if (request.item) p.Item = typedMapToAvMap(request.item);
+	if (request.keyConditionExpression) p.KeyConditionExpression = request.keyConditionExpression;
+	if (request.updateExpression) p.UpdateExpression = request.updateExpression;
+	if (request.conditionExpression) p.ConditionExpression = request.conditionExpression;
+	if (request.filterExpression) p.FilterExpression = request.filterExpression;
+	if (request.projectionExpression) p.ProjectionExpression = request.projectionExpression;
+	if (request.names) p.ExpressionAttributeNames = request.names;
+	if (request.typedValues) p.ExpressionAttributeValues = typedMapToAvMap(request.typedValues);
+	if (request.limit !== void 0) p.Limit = request.limit;
+	if (request.consistentRead) p.ConsistentRead = true;
+	if (request.scanIndexForward === false) p.ScanIndexForward = false;
+	if (request.exclusiveStartKey) p.ExclusiveStartKey = typedMapToAvMap(request.exclusiveStartKey);
+	return p;
+}
+/** JS expression decoding a base64 `B` member to the `Uint8Array` the client needs. */
+function jsBinary$1(base64) {
+	return `Uint8Array.from(atob(${JSON.stringify(base64)}), (c) => c.charCodeAt(0))`;
+}
+/**
+* Render a value as a pretty-printed (2-space) JS object literal, mirroring
+* `JSON.stringify(v, null, 2)` except that a `B`/`BS` AttributeValue member is
+* emitted as a `Uint8Array` expression rather than a base64 string.
+*/
+function jsLiteral(value, indent) {
+	const pad = "  ".repeat(indent);
+	const inner = "  ".repeat(indent + 1);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		return `[\n${value.map((v) => inner + jsLiteral(v, indent + 1)).join(",\n")}\n${pad}]`;
+	}
+	if (value && typeof value === "object") {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return "{}";
+		return `{\n${entries.map(([k, v]) => {
+			const key = JSON.stringify(k);
+			if (k === "B" && typeof v === "string") return `${inner}${key}: ${jsBinary$1(v)}`;
+			if (k === "BS" && Array.isArray(v)) return `${inner}${key}: [${v.map(jsBinary$1).join(", ")}]`;
+			return `${inner}${key}: ${jsLiteral(v, indent + 1)}`;
+		}).join(",\n")}\n${pad}}`;
+	}
+	if (typeof value === "string") return JSON.stringify(value);
+	return String(value);
+}
+/** Emit the `new <Op>Command({...})` source snippet for a canonical request. */
+function emitSdkV3(request) {
+	return `new ${COMMAND_BY_OP[request.operation]}(${jsLiteral(buildSdkV3Params(request), 0)})`;
+}
+/** The `@aws-sdk/client-dynamodb` command class name for an operation. */
+function sdkV3CommandName(operation) {
+	return COMMAND_BY_OP[operation];
+}
+/**
+* Render an arbitrary params value as the same pretty-printed JS literal
+* `emitSdkV3` embeds (B/BS members as `Uint8Array` expressions). Exported for
+* the query-builder program emitter, which composes its own statements around
+* the literal (client init + pagination loop) instead of a bare `new Command`.
+*/
+function renderJsValue(value, indent = 0) {
+	return jsLiteral(value, indent);
+}
+
+//#endregion
+//#region src/emit/cli.ts
+/** Operation → the `aws dynamodb` subcommand. */
+const SUBCOMMAND_BY_OP = {
+	GetItem: "get-item",
+	Query: "query",
+	Scan: "scan",
+	Update: "update-item",
+	Put: "put-item",
+	Delete: "delete-item"
+};
+/** Wrap a value in a POSIX single-quoted string, escaping inner single quotes. */
+function shellQuote(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** Compact DynamoDB-JSON for a typed map (no whitespace → a tight shell arg). */
+function avJson(map) {
+	return JSON.stringify(map);
+}
+/** Emit the multi-line `aws dynamodb <op>` command for a canonical request. */
+function emitCli(request) {
+	const flags = [["--table-name", request.tableName]];
+	if (request.indexName) flags.push(["--index-name", request.indexName]);
+	if (request.key) flags.push(["--key", avJson(typedMapToAvMap(request.key))]);
+	if (request.item) flags.push(["--item", avJson(typedMapToAvMap(request.item))]);
+	if (request.keyConditionExpression) flags.push(["--key-condition-expression", request.keyConditionExpression]);
+	if (request.updateExpression) flags.push(["--update-expression", request.updateExpression]);
+	if (request.conditionExpression) flags.push(["--condition-expression", request.conditionExpression]);
+	if (request.filterExpression) flags.push(["--filter-expression", request.filterExpression]);
+	if (request.projectionExpression) flags.push(["--projection-expression", request.projectionExpression]);
+	if (request.names) flags.push(["--expression-attribute-names", avJson(request.names)]);
+	if (request.typedValues) flags.push(["--expression-attribute-values", avJson(typedMapToAvMap(request.typedValues))]);
+	if (request.consistentRead) flags.push(["--consistent-read", null]);
+	if (request.scanIndexForward === false) flags.push(["--no-scan-index-forward", null]);
+	if (request.limit !== void 0) flags.push(["--page-size", String(request.limit)]);
+	const comments = request.exclusiveStartKey ? ["# The AWS CLI has no --exclusive-start-key: resume a paginated run with", "# --starting-token <NextToken from the previous run's output> instead."] : [];
+	const command = [`aws dynamodb ${SUBCOMMAND_BY_OP[request.operation]}`, ...flags.map(([flag, value]) => value === null ? `  ${flag}` : `  ${flag} ${shellQuote(value)}`)].join(" \\\n");
+	return comments.length > 0 ? [...comments, command].join("\n") : command;
+}
+
+//#endregion
+//#region src/emit/boto3.ts
+/** Operation → the low-level `boto3.client("dynamodb")` method. */
+const METHOD_BY_OP = {
+	GetItem: "get_item",
+	Query: "query",
+	Scan: "scan",
+	Update: "update_item",
+	Put: "put_item",
+	Delete: "delete_item"
+};
+/** Python expression decoding a base64 `B` member to the `bytes` the client needs. */
+function pyBinary(base64) {
+	return `base64.b64decode(${JSON.stringify(base64)})`;
+}
+/**
+* Render a JS value (string / boolean / array / object — the shapes a param
+* object and its AttributeValue maps contain) as a Python literal. Strings reuse
+* `JSON.stringify`, whose escapes (`\"`, `\\`, `\n`, `\uXXXX`) are all valid
+* Python; booleans become `True`/`False`. A `B`/`BS` AttributeValue member is
+* rendered as `bytes` (base64-decoded), not a str.
+*/
+function pyLiteral(value) {
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "boolean") return value ? "True" : "False";
+	if (typeof value === "number") return String(value);
+	if (Array.isArray(value)) return `[${value.map(pyLiteral).join(", ")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).map(([k, v]) => {
+		if (k === "B" && typeof v === "string") return `${JSON.stringify(k)}: ${pyBinary(v)}`;
+		if (k === "BS" && Array.isArray(v)) return `${JSON.stringify(k)}: [${v.map(pyBinary).join(", ")}]`;
+		return `${JSON.stringify(k)}: ${pyLiteral(v)}`;
+	}).join(", ")}}`;
+	return "None";
+}
+/**
+* Render a params value as the same Python literal `emitBoto3` embeds
+* (`True`/`False`/`None`, B/BS as `base64.b64decode(...)`). Exported for the
+* query-builder program emitter, which renders a `params` dict for its
+* LastEvaluatedKey pagination loop.
+*/
+function renderPyValue(value) {
+	return pyLiteral(value);
+}
+/** The low-level boto3 client method name for an operation. */
+function boto3MethodName(operation) {
+	return METHOD_BY_OP[operation];
+}
+/** Emit the runnable boto3 snippet (client + method call) for a canonical request. */
+function emitBoto3(request) {
+	const params = buildSdkV3Params(request);
+	const method = METHOD_BY_OP[request.operation];
+	const kwargs = Object.entries(params).map(([key, value]) => `    ${key}=${pyLiteral(value)},`);
+	return [
+		...hasBinaryValue(request) ? ["import base64", "import boto3"] : ["import boto3"],
+		"",
+		"client = boto3.client(\"dynamodb\")",
+		"",
+		`response = client.${method}(`,
+		...kwargs,
+		")"
+	].join("\n");
+}
+
+//#endregion
+//#region src/emit/partiql.ts
+/** Thrown internally to short-circuit out of a partly-built statement. */
+var NotExpressibleError = class extends Error {};
+/** Bail out: this request has no faithful PartiQL form. */
+function notExpressible(reason) {
+	throw new NotExpressibleError(reason);
+}
+/** Double-quote an identifier (reserved-word-safe), doubling any inner `"`. */
+function quoteIdent(name) {
+	return `"${name.replace(/"/g, "\"\"")}"`;
+}
+/** Single-quote a string literal, doubling any inner `'` (PartiQL escaping). */
+function quoteString(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+const NUMERIC = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+/** A typed value as a PartiQL literal — built from the tag, never the runtime. */
+function literal(tv) {
+	switch (tv.type) {
+		case "S": return quoteString(tv.value);
+		case "N":
+			if (!NUMERIC.test(tv.value.trim())) return notExpressible(`non-numeric N value "${tv.value}" has no PartiQL literal form`);
+			return tv.value;
+		case "BOOL": return tv.value === "true" ? "true" : "false";
+		case "NULL": return "NULL";
+		case "B": return notExpressible("binary (B) values have no PartiQL literal form — use the SDK/CLI emitter");
+		case "SS":
+		case "NS":
+		case "BS": return notExpressible("set-typed values have no PartiQL literal form — use the SDK/CLI emitter");
+	}
+}
+/** `"Table"` or `"Table"."Index"`. */
+function fromClause(config) {
+	const table = quoteIdent(config.tableName);
+	return config.indexName ? `${table}.${quoteIdent(config.indexName)}` : table;
+}
+/** Projected attributes → `"a", "b"`, or `*` when no projection is set. */
+function selectList(config) {
+	const proj = config.projection;
+	if (proj && proj.length > 0) return proj.map(quoteIdent).join(", ");
+	return "*";
+}
+/** A FilterRow's single RHS value as a typed value (set-/scalar-aware). */
+function single(row) {
+	return makeTypedValue(row.type, row.value, row.values);
+}
+/**
+* Compile one predicate row (filter, condition, or — structurally compatible —
+* a range-key condition) into a PartiQL boolean expression. Operators PartiQL
+* can't express (`size_*`, `type_*`) degrade the whole statement.
+*/
+function predicate(row) {
+	const id = quoteIdent(row.field);
+	switch (OPERATOR_BY_VALUE[row.operator].wireForm) {
+		case "EQ": return `${id} = ${literal(single(row))}`;
+		case "NE": return `${id} <> ${literal(single(row))}`;
+		case "LT": return `${id} < ${literal(single(row))}`;
+		case "LE": return `${id} <= ${literal(single(row))}`;
+		case "GT": return `${id} > ${literal(single(row))}`;
+		case "GE": return `${id} >= ${literal(single(row))}`;
+		case "BETWEEN": return `${id} BETWEEN ${literal(makeTypedValue(row.type, row.value))} AND ${literal(makeTypedValue(row.type, row.value2 ?? ""))}`;
+		case "BEGINS_WITH": return `begins_with(${id}, ${literal(single(row))})`;
+		case "CONTAINS": return `contains(${id}, ${literal(makeTypedValue(elementType(row.type), row.value))})`;
+		case "IN": return `${id} IN (${(row.values ?? (row.value ? [row.value] : [])).map((m) => literal(makeTypedValue(row.type, m))).join(", ")})`;
+		case "EXISTS": return `${id} IS NOT MISSING`;
+		case "NOT_EXISTS": return `${id} IS MISSING`;
+		case "SIZE_EQ":
+		case "SIZE_NE":
+		case "SIZE_LT":
+		case "SIZE_LE":
+		case "SIZE_GT":
+		case "SIZE_GE": return notExpressible("size() comparisons are not expressible in PartiQL");
+		case "TYPE_EQ":
+		case "TYPE_NE": return notExpressible("attribute_type() checks are not expressible in PartiQL");
+	}
+}
+/** Equality predicates for an exact primary key (GetItem/Update/Delete). */
+function keyPredicates(keys) {
+	return keys.map((k) => `${quoteIdent(k.field)} = ${literal(makeTypedValue(k.type, k.value))}`);
+}
+/** One SET action → a PartiQL `SET` body, degrading on the inexpressible idioms. */
+function setClause(action) {
+	const id = quoteIdent(action.field);
+	const value = action.value;
+	if (!value) throw new Error(`SET on "${action.field}" requires a value`);
+	switch (action.setOp ?? "assign") {
+		case "assign": return `${id} = ${literal(value)}`;
+		case "add":
+		case "subtract": return notExpressible("atomic counters (SET x = x ± n) are not expressible in PartiQL — use the SDK/CLI emitter");
+		case "if_not_exists": return notExpressible("if_not_exists() is not expressible in PartiQL");
+		case "list_append":
+		case "list_prepend": return notExpressible("list_append() is not expressible in PartiQL");
+	}
+}
+function buildSelect(config) {
+	if (config.limit !== void 0) notExpressible("Limit is an ExecuteStatement API parameter, not part of the PartiQL statement — use the SDK/CLI emitter");
+	if (config.consistentRead) notExpressible("ConsistentRead is an ExecuteStatement API parameter, not part of the PartiQL statement — use the SDK/CLI emitter");
+	if (config.exclusiveStartKey && config.exclusiveStartKey.length > 0) notExpressible("PartiQL paginates with an opaque NextToken, not ExclusiveStartKey — use the SDK/CLI emitter");
+	const head = `SELECT ${selectList(config)}\nFROM ${fromClause(config)}`;
+	if (config.operation === "GetItem") {
+		if (!config.key || config.key.length === 0) notExpressible("GetItem requires the full primary key in WHERE");
+		return `${head}\nWHERE ${keyPredicates(config.key).join("\n  AND ")}`;
+	}
+	if (config.operation === "Query") {
+		if (!config.hashKey) notExpressible("Query requires a hash key");
+		const preds$1 = [predicate({
+			field: config.hashKey.field,
+			operator: "=",
+			type: config.hashKey.type,
+			value: config.hashKey.value
+		})];
+		if (config.rangeKey) preds$1.push(predicate(config.rangeKey));
+		for (const filter of config.filters ?? []) preds$1.push(predicate(filter));
+		const select = `${head}\nWHERE ${preds$1.join("\n  AND ")}`;
+		if (config.scanIndexForward === false) {
+			if (!config.rangeKey) notExpressible("descending order needs ORDER BY on the sort key — add a sort key condition, or use the SDK/CLI emitter");
+			return `${select}\nORDER BY ${quoteIdent(config.rangeKey.field)} DESC`;
+		}
+		return select;
+	}
+	const preds = (config.filters ?? []).map(predicate);
+	return preds.length ? `${head}\nWHERE ${preds.join("\n  AND ")}` : head;
+}
+function buildUpdate(config) {
+	if (!config.key || config.key.length === 0) notExpressible("UPDATE requires the full primary key in WHERE");
+	const parts = [`UPDATE ${fromClause(config)}`];
+	for (const action of config.updates ?? []) switch (action.kind) {
+		case "SET":
+			parts.push(`SET ${setClause(action)}`);
+			break;
+		case "REMOVE":
+			parts.push(`REMOVE ${action.index === void 0 ? quoteIdent(action.field) : `${quoteIdent(action.field)}[${action.index}]`}`);
+			break;
+		case "ADD":
+		case "DELETE": notExpressible(action.kind === "ADD" ? "ADD is not expressible in PartiQL" : "set DELETE is not expressible in PartiQL");
+	}
+	const where = [...keyPredicates(config.key), ...(config.conditions ?? []).map(predicate)];
+	parts.push(`WHERE ${where.join("\n  AND ")}`);
+	return parts.join("\n");
+}
+function buildInsert(config) {
+	if (config.conditions && config.conditions.length > 0) notExpressible("a conditional Put has no condition-less PartiQL INSERT — use the SDK/CLI emitter");
+	const entries = (config.item ?? []).map((attr) => `${quoteString(attr.field)}: ${literal(makeTypedValue(attr.type, attr.value, attr.values))}`);
+	return `INSERT INTO ${fromClause(config)} VALUE {${entries.join(", ")}}`;
+}
+function buildDelete(config) {
+	if (!config.key || config.key.length === 0) notExpressible("DELETE requires the full primary key in WHERE");
+	const where = [...keyPredicates(config.key), ...(config.conditions ?? []).map(predicate)];
+	return `DELETE FROM ${fromClause(config)}\nWHERE ${where.join("\n  AND ")}`;
+}
+function buildStatement(config) {
+	switch (config.operation) {
+		case "GetItem":
+		case "Query":
+		case "Scan": return buildSelect(config);
+		case "Update": return buildUpdate(config);
+		case "Put": return buildInsert(config);
+		case "Delete": return buildDelete(config);
+	}
+}
+/**
+* Emit a PartiQL statement for a canonical request, or an honest
+* `{ ok: false, reason }` when the request has no faithful PartiQL form.
+*/
+function emitPartiql(request) {
+	try {
+		return {
+			ok: true,
+			statement: buildStatement(request.config)
+		};
+	} catch (error) {
+		if (error instanceof NotExpressibleError) return {
+			ok: false,
+			reason: error.message
+		};
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/emit/java.ts
+/** Operation → the `software.amazon.awssdk.services.dynamodb.model` request class. */
+const REQUEST_CLASS_BY_OP$1 = {
+	GetItem: "GetItemRequest",
+	Query: "QueryRequest",
+	Scan: "ScanRequest",
+	Update: "UpdateItemRequest",
+	Put: "PutItemRequest",
+	Delete: "DeleteItemRequest"
+};
+/** Operation → the `DynamoDbClient` method. */
+const CLIENT_METHOD_BY_OP$2 = {
+	GetItem: "getItem",
+	Query: "query",
+	Scan: "scan",
+	Update: "updateItem",
+	Put: "putItem",
+	Delete: "deleteItem"
+};
+/** The model request class name for an operation (`QueryRequest`, …). */
+function javaRequestClassName(operation) {
+	return REQUEST_CLASS_BY_OP$1[operation];
+}
+/** The `DynamoDbClient` method name for an operation (`query`, …). */
+function javaClientMethodName(operation) {
+	return CLIENT_METHOD_BY_OP$2[operation];
+}
+/** Java string literal — `JSON.stringify` escapes are all valid Java escapes. */
+function javaString(value) {
+	return JSON.stringify(value);
+}
+/** Java expression decoding a base64 `B` member to the `SdkBytes` the client needs. */
+function javaBinary(base64) {
+	return `SdkBytes.fromByteArray(Base64.getDecoder().decode(${javaString(base64)}))`;
+}
+/** Render one wire AttributeValue as an `AttributeValue.builder()…build()` chain. */
+function renderJavaAv(av) {
+	if ("S" in av) return `AttributeValue.builder().s(${javaString(av.S)}).build()`;
+	if ("N" in av) return `AttributeValue.builder().n(${javaString(av.N)}).build()`;
+	if ("B" in av) return `AttributeValue.builder().b(${javaBinary(av.B)}).build()`;
+	if ("BOOL" in av) return `AttributeValue.builder().bool(${av.BOOL}).build()`;
+	if ("SS" in av) return `AttributeValue.builder().ss(${av.SS.map(javaString).join(", ")}).build()`;
+	if ("NS" in av) return `AttributeValue.builder().ns(${av.NS.map(javaString).join(", ")}).build()`;
+	if ("BS" in av) return `AttributeValue.builder().bs(${av.BS.map(javaBinary).join(", ")}).build()`;
+	return "AttributeValue.builder().nul(true).build()";
+}
+/** Render a typed map as `Map.ofEntries(Map.entry(name, <AV builder>), …)`. */
+function renderJavaAvMap(map, indent) {
+	const inner = `${indent}    `;
+	return `Map.ofEntries(\n${Object.entries(typedMapToAvMap(map)).map(([name, av]) => `${inner}Map.entry(${javaString(name)}, ${renderJavaAv(av)})`).join(",\n")}\n${indent})`;
+}
+/** Render the plain string name map (`ExpressionAttributeNames`). */
+function renderJavaNameMap(map, indent) {
+	const inner = `${indent}    `;
+	return `Map.ofEntries(\n${Object.entries(map).map(([alias, name]) => `${inner}Map.entry(${javaString(alias)}, ${javaString(name)})`).join(",\n")}\n${indent})`;
+}
+/**
+* Render the `<Op>Request.builder()…build()` expression, each setter on its own
+* line at `indent + 4` spaces. Exported for the query-builder program emitter,
+* which wraps the same expression in a runnable class (client init + send +
+* pagination loop); `extraSetters` lets it append loop-owned setters (e.g.
+* `.exclusiveStartKey(lastEvaluatedKey)`) before `.build()`.
+*/
+function renderJavaRequestBuilder(request, indent, extraSetters = []) {
+	const pad = `${indent}    `;
+	const setters = [`.tableName(${javaString(request.tableName)})`];
+	if (request.indexName) setters.push(`.indexName(${javaString(request.indexName)})`);
+	if (request.key) setters.push(`.key(${renderJavaAvMap(request.key, pad)})`);
+	if (request.item) setters.push(`.item(${renderJavaAvMap(request.item, pad)})`);
+	if (request.keyConditionExpression) setters.push(`.keyConditionExpression(${javaString(request.keyConditionExpression)})`);
+	if (request.updateExpression) setters.push(`.updateExpression(${javaString(request.updateExpression)})`);
+	if (request.conditionExpression) setters.push(`.conditionExpression(${javaString(request.conditionExpression)})`);
+	if (request.filterExpression) setters.push(`.filterExpression(${javaString(request.filterExpression)})`);
+	if (request.projectionExpression) setters.push(`.projectionExpression(${javaString(request.projectionExpression)})`);
+	if (request.names) setters.push(`.expressionAttributeNames(${renderJavaNameMap(request.names, pad)})`);
+	if (request.typedValues) setters.push(`.expressionAttributeValues(${renderJavaAvMap(request.typedValues, pad)})`);
+	if (request.limit !== void 0) setters.push(`.limit(${request.limit})`);
+	if (request.consistentRead) setters.push(".consistentRead(true)");
+	if (request.scanIndexForward === false) setters.push(".scanIndexForward(false)");
+	if (request.exclusiveStartKey) setters.push(`.exclusiveStartKey(${renderJavaAvMap(request.exclusiveStartKey, pad)})`);
+	const lines = [
+		...setters,
+		...extraSetters,
+		".build()"
+	].map((s) => `${pad}${s}`);
+	return [`${REQUEST_CLASS_BY_OP$1[request.operation]}.builder()`, ...lines].join("\n");
+}
+/** Emit the bare `<Op>Request.builder()…build()` snippet for a canonical request. */
+function emitJava(request) {
+	return renderJavaRequestBuilder(request, "");
+}
+
+//#endregion
+//#region src/emit/go.ts
+/** Operation → the `dynamodb.<Op>Input` struct name. */
+const INPUT_TYPE_BY_OP = {
+	GetItem: "GetItemInput",
+	Query: "QueryInput",
+	Scan: "ScanInput",
+	Update: "UpdateItemInput",
+	Put: "PutItemInput",
+	Delete: "DeleteItemInput"
+};
+/** Operation → the `dynamodb.Client` method. */
+const CLIENT_METHOD_BY_OP$1 = {
+	GetItem: "GetItem",
+	Query: "Query",
+	Scan: "Scan",
+	Update: "UpdateItem",
+	Put: "PutItem",
+	Delete: "DeleteItem"
+};
+/** The `dynamodb.<Op>Input` struct name for an operation. */
+function goInputTypeName(operation) {
+	return INPUT_TYPE_BY_OP[operation];
+}
+/** The `dynamodb.Client` method name for an operation. */
+function goClientMethodName(operation) {
+	return CLIENT_METHOD_BY_OP$1[operation];
+}
+/** Go string literal — `JSON.stringify` escapes are all valid Go escapes. */
+function goString(value) {
+	return JSON.stringify(value);
+}
+/** Decode canonical base64 into a Go `[]byte{0x…}` literal (fail-loud on bad input). */
+function goBytes(base64) {
+	let raw;
+	try {
+		raw = atob(base64);
+	} catch {
+		throw new Error(`invalid base64 in a binary (B/BS) value: ${base64}`);
+	}
+	return `[]byte{${Array.from(raw, (c) => `0x${c.charCodeAt(0).toString(16).padStart(2, "0")}`).join(", ")}}`;
+}
+/** Render one wire AttributeValue as a `&types.AttributeValueMember*` literal. */
+function renderGoAv(av) {
+	if ("S" in av) return `&types.AttributeValueMemberS{Value: ${goString(av.S)}}`;
+	if ("N" in av) return `&types.AttributeValueMemberN{Value: ${goString(av.N)}}`;
+	if ("B" in av) return `&types.AttributeValueMemberB{Value: ${goBytes(av.B)}}`;
+	if ("BOOL" in av) return `&types.AttributeValueMemberBOOL{Value: ${av.BOOL}}`;
+	if ("SS" in av) return `&types.AttributeValueMemberSS{Value: []string{${av.SS.map(goString).join(", ")}}}`;
+	if ("NS" in av) return `&types.AttributeValueMemberNS{Value: []string{${av.NS.map(goString).join(", ")}}}`;
+	if ("BS" in av) return `&types.AttributeValueMemberBS{Value: [][]byte{${av.BS.map(goBytes).join(", ")}}}`;
+	return "&types.AttributeValueMemberNULL{Value: true}";
+}
+/** Render a typed map as a `map[string]types.AttributeValue{…}` literal. */
+function renderGoAvMap(map, indent) {
+	const inner = `${indent}\t`;
+	return `map[string]types.AttributeValue{\n${Object.entries(typedMapToAvMap(map)).map(([name, av]) => `${inner}${goString(name)}: ${renderGoAv(av)},`).join("\n")}\n${indent}}`;
+}
+/** Render the plain string name map (`ExpressionAttributeNames`). */
+function renderGoNameMap(map, indent) {
+	const inner = `${indent}\t`;
+	return `map[string]string{\n${Object.entries(map).map(([alias, name]) => `${inner}${goString(alias)}: ${goString(name)},`).join("\n")}\n${indent}}`;
+}
+/**
+* Render the `&dynamodb.<Op>Input{…}` composite literal, one field per line at
+* `indent + \t`. Exported for the query-builder program emitter, which wraps
+* the same literal in a runnable `main.go` (config load + client + paginator).
+*/
+function renderGoInput(request, indent) {
+	const pad = `${indent}\t`;
+	const fields = [`TableName: aws.String(${goString(request.tableName)}),`];
+	if (request.indexName) fields.push(`IndexName: aws.String(${goString(request.indexName)}),`);
+	if (request.key) fields.push(`Key: ${renderGoAvMap(request.key, pad)},`);
+	if (request.item) fields.push(`Item: ${renderGoAvMap(request.item, pad)},`);
+	if (request.keyConditionExpression) fields.push(`KeyConditionExpression: aws.String(${goString(request.keyConditionExpression)}),`);
+	if (request.updateExpression) fields.push(`UpdateExpression: aws.String(${goString(request.updateExpression)}),`);
+	if (request.conditionExpression) fields.push(`ConditionExpression: aws.String(${goString(request.conditionExpression)}),`);
+	if (request.filterExpression) fields.push(`FilterExpression: aws.String(${goString(request.filterExpression)}),`);
+	if (request.projectionExpression) fields.push(`ProjectionExpression: aws.String(${goString(request.projectionExpression)}),`);
+	if (request.names) fields.push(`ExpressionAttributeNames: ${renderGoNameMap(request.names, pad)},`);
+	if (request.typedValues) fields.push(`ExpressionAttributeValues: ${renderGoAvMap(request.typedValues, pad)},`);
+	if (request.limit !== void 0) fields.push(`Limit: aws.Int32(${request.limit}),`);
+	if (request.consistentRead) fields.push("ConsistentRead: aws.Bool(true),");
+	if (request.scanIndexForward === false) fields.push("ScanIndexForward: aws.Bool(false),");
+	if (request.exclusiveStartKey) fields.push(`ExclusiveStartKey: ${renderGoAvMap(request.exclusiveStartKey, pad)},`);
+	const lines = fields.map((f) => `${pad}${f}`);
+	return [
+		`&dynamodb.${INPUT_TYPE_BY_OP[request.operation]}{`,
+		...lines,
+		`${indent}}`
+	].join("\n");
+}
+/**
+* Does this request render any `types.AttributeValue` (AV map)? Drives the
+* `dynamodb/types` import in the program emitter.
+*/
+function goUsesTypes(request) {
+	return request.key !== void 0 || request.item !== void 0 || request.typedValues !== void 0 || request.exclusiveStartKey !== void 0;
+}
+/** Emit the bare `&dynamodb.<Op>Input{…}` snippet for a canonical request. */
+function emitGo(request) {
+	return renderGoInput(request, "");
+}
+
+//#endregion
+//#region src/emit/dotnet.ts
+/** Operation → the `Amazon.DynamoDBv2.Model` request class. */
+const REQUEST_CLASS_BY_OP = {
+	GetItem: "GetItemRequest",
+	Query: "QueryRequest",
+	Scan: "ScanRequest",
+	Update: "UpdateItemRequest",
+	Put: "PutItemRequest",
+	Delete: "DeleteItemRequest"
+};
+/** Operation → the async `AmazonDynamoDBClient` method. */
+const CLIENT_METHOD_BY_OP = {
+	GetItem: "GetItemAsync",
+	Query: "QueryAsync",
+	Scan: "ScanAsync",
+	Update: "UpdateItemAsync",
+	Put: "PutItemAsync",
+	Delete: "DeleteItemAsync"
+};
+/** The model request class name for an operation (`QueryRequest`, …). */
+function dotnetRequestClassName(operation) {
+	return REQUEST_CLASS_BY_OP[operation];
+}
+/** The async client method name for an operation (`QueryAsync`, …). */
+function dotnetClientMethodName(operation) {
+	return CLIENT_METHOD_BY_OP[operation];
+}
+/** C# string literal — `JSON.stringify` escapes are all valid C# escapes. */
+function csString(value) {
+	return JSON.stringify(value);
+}
+/** C# expression decoding a base64 `B` member to the `MemoryStream` the client needs. */
+function csBinary(base64) {
+	return `new MemoryStream(Convert.FromBase64String(${csString(base64)}))`;
+}
+/** Render one wire AttributeValue as a `new AttributeValue { … }` initializer. */
+function renderCsAv(av) {
+	if ("S" in av) return `new AttributeValue { S = ${csString(av.S)} }`;
+	if ("N" in av) return `new AttributeValue { N = ${csString(av.N)} }`;
+	if ("B" in av) return `new AttributeValue { B = ${csBinary(av.B)} }`;
+	if ("BOOL" in av) return `new AttributeValue { BOOL = ${av.BOOL} }`;
+	if ("SS" in av) return `new AttributeValue { SS = new List<string> { ${av.SS.map(csString).join(", ")} } }`;
+	if ("NS" in av) return `new AttributeValue { NS = new List<string> { ${av.NS.map(csString).join(", ")} } }`;
+	if ("BS" in av) return `new AttributeValue { BS = new List<MemoryStream> { ${av.BS.map(csBinary).join(", ")} } }`;
+	return "new AttributeValue { NULL = true }";
+}
+/** Render a typed map as a `Dictionary<string, AttributeValue>` initializer. */
+function renderCsAvMap(map, indent) {
+	const inner = `${indent}    `;
+	return `new Dictionary<string, AttributeValue>\n${indent}{\n${Object.entries(typedMapToAvMap(map)).map(([name, av]) => `${inner}[${csString(name)}] = ${renderCsAv(av)},`).join("\n")}\n${indent}}`;
+}
+/** Render the plain string name map (`ExpressionAttributeNames`). */
+function renderCsNameMap(map, indent) {
+	const inner = `${indent}    `;
+	return `new Dictionary<string, string>\n${indent}{\n${Object.entries(map).map(([alias, name]) => `${inner}[${csString(alias)}] = ${csString(name)},`).join("\n")}\n${indent}}`;
+}
+/**
+* Render the `new <Op>Request { … }` object initializer, one property per line
+* at `indent + 4` spaces. Exported for the query-builder program emitter, which
+* wraps the same initializer in a runnable program (client init + await send +
+* pagination loop).
+*/
+function renderCsRequest(request, indent) {
+	const pad = `${indent}    `;
+	const props = [`TableName = ${csString(request.tableName)},`];
+	if (request.indexName) props.push(`IndexName = ${csString(request.indexName)},`);
+	if (request.key) props.push(`Key = ${renderCsAvMap(request.key, pad)},`);
+	if (request.item) props.push(`Item = ${renderCsAvMap(request.item, pad)},`);
+	if (request.keyConditionExpression) props.push(`KeyConditionExpression = ${csString(request.keyConditionExpression)},`);
+	if (request.updateExpression) props.push(`UpdateExpression = ${csString(request.updateExpression)},`);
+	if (request.conditionExpression) props.push(`ConditionExpression = ${csString(request.conditionExpression)},`);
+	if (request.filterExpression) props.push(`FilterExpression = ${csString(request.filterExpression)},`);
+	if (request.projectionExpression) props.push(`ProjectionExpression = ${csString(request.projectionExpression)},`);
+	if (request.names) props.push(`ExpressionAttributeNames = ${renderCsNameMap(request.names, pad)},`);
+	if (request.typedValues) props.push(`ExpressionAttributeValues = ${renderCsAvMap(request.typedValues, pad)},`);
+	if (request.limit !== void 0) props.push(`Limit = ${request.limit},`);
+	if (request.consistentRead) props.push("ConsistentRead = true,");
+	if (request.scanIndexForward === false) props.push("ScanIndexForward = false,");
+	if (request.exclusiveStartKey) props.push(`ExclusiveStartKey = ${renderCsAvMap(request.exclusiveStartKey, pad)},`);
+	const lines = props.map((p) => `${pad}${p}`);
+	return [
+		`new ${REQUEST_CLASS_BY_OP[request.operation]}`,
+		`${indent}{`,
+		...lines,
+		`${indent}}`
+	].join("\n");
+}
+/** Emit the bare `new <Op>Request { … }` snippet for a canonical request. */
+function emitDotnet(request) {
+	return renderCsRequest(request, "");
+}
+
+//#endregion
+//#region src/emit/ddbtoolbox.ts
+/** Key attr DynamoDB type (S/N/B) → the Table `type` string dynamodb-toolbox wants. */
+function tableKeyType(type) {
+	if (type === "N") return "'number'";
+	if (type === "B") return "'binary'";
+	return "'string'";
+}
+/** JS expression decoding a base64 `B` value to the `Uint8Array` the client wants. */
+function jsBinary(base64) {
+	return `Uint8Array.from(atob(${JSON.stringify(base64)}), (c) => c.charCodeAt(0))`;
+}
+/**
+* Render a {@link TypedValue} as the NATIVE JS literal dynamodb-toolbox expects
+* (the DocumentClient does the low-level AttributeValue marshalling): a bare
+* number for N, a `Uint8Array` for B, a real `Set` for SS/NS/BS.
+*/
+function renderNativeValue(tv) {
+	switch (tv.type) {
+		case "S": return JSON.stringify(tv.value);
+		case "N": return tv.value;
+		case "B": return jsBinary(tv.value);
+		case "BOOL": return tv.value === "true" ? "true" : "false";
+		case "NULL": return "null";
+		case "SS": return `new Set([${(tv.values ?? []).map((v) => JSON.stringify(v)).join(", ")}])`;
+		case "NS": return `new Set([${(tv.values ?? []).join(", ")}])`;
+		case "BS": return `new Set([${(tv.values ?? []).map(jsBinary).join(", ")}])`;
+	}
+}
+/** Build a scalar TypedValue from a tag + raw string (for key/range/filter RHS). */
+function scalar(type, value) {
+	return {
+		type,
+		value
+	};
+}
+/** lowercase comparison operator → dynamodb-toolbox condition key. */
+const COMPARATOR_KEY = {
+	"=": "eq",
+	"<>": "ne",
+	"<": "lt",
+	"<=": "lte",
+	">": "gt",
+	">=": "gte"
+};
+/** size_* operator → the comparator key its number pairs with. */
+const SIZE_COMPARATOR = {
+	size_eq: "eq",
+	size_ne: "ne",
+	size_lt: "lt",
+	size_le: "lte",
+	size_gt: "gt",
+	size_ge: "gte"
+};
+/**
+* Render one filter row as a dynamodb-toolbox condition object. `size_*` targets
+* a path via the `size` key (`{ size: 'attr', gt: 3 }`); `type_ne` has no direct
+* form so it degrades to `{ not: { attr, type } }`.
+*/
+function renderCondition(f) {
+	const attr = JSON.stringify(f.field);
+	const val = () => renderNativeValue(scalar(f.type, f.value));
+	if (f.operator === "exists") return `{ attr: ${attr}, exists: true }`;
+	if (f.operator === "not_exists") return `{ attr: ${attr}, exists: false }`;
+	if (f.operator === "contains") return `{ attr: ${attr}, contains: ${val()} }`;
+	if (f.operator === "begins_with") return `{ attr: ${attr}, beginsWith: ${val()} }`;
+	if (f.operator === "between") return `{ attr: ${attr}, between: [${renderNativeValue(scalar(f.type, f.value))}, ${renderNativeValue(scalar(f.type, f.value2 ?? ""))}] }`;
+	if (f.operator === "in") return `{ attr: ${attr}, in: [${(f.values ?? []).map((v) => renderNativeValue(scalar(f.type, v))).join(", ")}] }`;
+	if (f.operator === "type_eq") return `{ attr: ${attr}, type: ${JSON.stringify(f.value)} }`;
+	if (f.operator === "type_ne") return `{ not: { attr: ${attr}, type: ${JSON.stringify(f.value)} } }`;
+	const sizeKey = SIZE_COMPARATOR[f.operator];
+	if (sizeKey) return `{ size: ${attr}, ${sizeKey}: ${f.value} }`;
+	const cmp = COMPARATOR_KEY[f.operator];
+	if (cmp) return `{ attr: ${attr}, ${cmp}: ${val()} }`;
+	throw new Error(`dynamodb-toolbox: unsupported filter operator "${f.operator}"`);
+}
+/** Compose the filter option — a single condition, or `{ and: [...] }` for several. */
+function renderFilter(filters) {
+	const conds = filters.map(renderCondition);
+	if (conds.length === 1) return conds[0];
+	return `{ and: [${conds.map((c) => `\n      ${c}`).join(",")}\n    ] }`;
+}
+/** A `{ name, type }` key-attr line for a Table partition/sort key. */
+function keyLine(field, type) {
+	return `{ name: ${JSON.stringify(field)}, type: ${tableKeyType(type)} }`;
+}
+/**
+* Render the `new Table({...})` scaffold. A base-table Query knows its real
+* PK/SK; a Scan or a GSI query does NOT (the request's key belongs to the GSI),
+* so it emits `config.baseKeySchema` when supplied, else a placeholder base PK
+* the developer replaces.
+*/
+function renderTable(config) {
+	const lines = [`  name: ${JSON.stringify(config.tableName)},`];
+	if (config.operation === "Query" && !config.indexName && config.hashKey) {
+		lines.push(`  partitionKey: ${keyLine(config.hashKey.field, config.hashKey.type)},`);
+		if (config.rangeKey) lines.push(`  sortKey: ${keyLine(config.rangeKey.field, config.rangeKey.type)},`);
+	} else if (config.baseKeySchema) {
+		const { hashKey, rangeKey } = config.baseKeySchema;
+		lines.push(`  partitionKey: ${keyLine(hashKey.field, hashKey.type)},`);
+		if (rangeKey) lines.push(`  sortKey: ${keyLine(rangeKey.field, rangeKey.type)},`);
+	} else lines.push("  // TODO: replace with your table's real key schema (unknown from this query alone)", "  partitionKey: { name: 'PK', type: 'string' },");
+	if (config.indexName && config.hashKey) {
+		const idx = [
+			`    ${JSON.stringify(config.indexName)}: {`,
+			`      type: 'global',`,
+			`      partitionKey: ${keyLine(config.hashKey.field, config.hashKey.type)},`,
+			...config.rangeKey ? [`      sortKey: ${keyLine(config.rangeKey.field, config.rangeKey.type)},`] : [],
+			"    }"
+		];
+		lines.push(`  indexes: {\n${idx.join("\n")}\n  },`);
+	}
+	return [
+		"const table = new Table({",
+		"  documentClient,",
+		...lines,
+		"});"
+	].join("\n");
+}
+/** The `.query({...})` argument for a Query (partition [+ range] [+ index]). */
+function renderQueryArg(config) {
+	if (!config.hashKey) throw new Error("dynamodb-toolbox: Query requires a partition key");
+	const parts = [`partition: ${renderNativeValue(scalar(config.hashKey.type, config.hashKey.value))}`];
+	if (config.rangeKey) parts.push(`range: ${renderRange(config.rangeKey)}`);
+	if (config.indexName) parts.push(`index: ${JSON.stringify(config.indexName)}`);
+	return `{ ${parts.join(", ")} }`;
+}
+/** A sort-key `range` condition: `{ beginsWith: 'x' }` / `{ between: [a, b] }` / … */
+function renderRange(range) {
+	const v = () => renderNativeValue(scalar(range.type, range.value));
+	if (range.operator === "begins_with") return `{ beginsWith: ${v()} }`;
+	if (range.operator === "between") return `{ between: [${renderNativeValue(scalar(range.type, range.value))}, ${renderNativeValue(scalar(range.type, range.value2 ?? ""))}] }`;
+	const cmp = COMPARATOR_KEY[range.operator];
+	if (cmp) return `{ ${cmp}: ${v()} }`;
+	throw new Error(`dynamodb-toolbox: unsupported range operator "${range.operator}"`);
+}
+/** Native key map for `exclusiveStartKey` (typed KeyAttr[] → `{ pk: 'x' }`). */
+function renderKeyMap(key) {
+	return `{ ${key.map((k) => `${JSON.stringify(k.field)}: ${renderNativeValue(scalar(k.type, k.value))}`).join(", ")} }`;
+}
+/**
+* The `.options({...})` entries. When `paginate`, `exclusiveStartKey` is OWNED
+* by the loop (seeded from the manual resume point there), so it is omitted here
+* — the loop appends its own `exclusiveStartKey` shorthand entry instead.
+*/
+function optionEntries(config, paginate) {
+	const opts = [];
+	if (config.filters && config.filters.length > 0) opts.push(`filter: ${renderFilter(config.filters)}`);
+	if (config.limit !== void 0) opts.push(`limit: ${config.limit}`);
+	if (config.consistentRead) opts.push("consistent: true");
+	if (config.operation === "Query" && config.scanIndexForward === false) opts.push("reverse: true");
+	if (config.projection && config.projection.length > 0) opts.push(`attributes: [${config.projection.map((a) => JSON.stringify(a)).join(", ")}]`);
+	if (!paginate && config.exclusiveStartKey && config.exclusiveStartKey.length > 0) opts.push(`exclusiveStartKey: ${renderKeyMap(config.exclusiveStartKey)}`);
+	return opts;
+}
+/** Wrap `optionEntries` into the `.options({...})` object literal. */
+function renderOptions(config, paginate) {
+	const opts = optionEntries(config, paginate);
+	return opts.length > 0 ? `{ ${opts.join(", ")} }` : "{}";
+}
+/**
+* Emit the runnable dynamodb-toolbox program for a Query/Scan canonical request.
+* `paginate` wraps the send in a `LastEvaluatedKey` loop (dynamodb-toolbox's
+* `send()` returns `{ Items, LastEvaluatedKey }` and takes `exclusiveStartKey`).
+*/
+function emitDdbToolboxProgram(request, paginate) {
+	const config = request.config;
+	const isQuery = config.operation === "Query";
+	const command = isQuery ? "QueryCommand" : "ScanCommand";
+	const header = [
+		`import { DynamoDBClient } from "@aws-sdk/client-dynamodb";`,
+		`import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";`,
+		`import { Table } from "dynamodb-toolbox/table";`,
+		`import { ${command} } from ${isQuery ? "'dynamodb-toolbox/table/actions/query'" : "'dynamodb-toolbox/table/actions/scan'"};`,
+		"",
+		"const documentClient = DynamoDBDocumentClient.from(new DynamoDBClient({}));",
+		"",
+		renderTable(config),
+		""
+	];
+	const queryLine = isQuery ? `  .query(${renderQueryArg(config)})\n` : "";
+	if (!paginate) return [
+		...header,
+		"const response = await table",
+		`  .build(${command})`,
+		`${queryLine}  .options(${renderOptions(config, false)})`,
+		"  .send();",
+		"",
+		"console.log(response.Items);"
+	].join("\n");
+	const seed = config.exclusiveStartKey && config.exclusiveStartKey.length > 0 ? ` = ${renderKeyMap(config.exclusiveStartKey)}` : "";
+	const loopOptions = `{ ${[...optionEntries(config, true), "exclusiveStartKey"].join(", ")} }`;
+	return [
+		...header,
+		"const items = [];",
+		`let exclusiveStartKey${seed};`,
+		"do {",
+		"  const response = await table",
+		`    .build(${command})`,
+		isQuery ? `    .query(${renderQueryArg(config)})` : null,
+		`    .options(${loopOptions})`,
+		"    .send();",
+		"  items.push(...(response.Items ?? []));",
+		"  exclusiveStartKey = response.LastEvaluatedKey;",
+		"} while (exclusiveStartKey);",
+		"",
+		"console.log(items);"
+	].filter((l) => l !== null).join("\n");
+}
+
+//#endregion
+//#region src/program.ts
+/**
+* Emit the runnable program for a Query/Scan config in the given format.
+* Throws on a non-read operation (the widget never produces one — programmer
+* error, mirroring `buildRequest`'s fail-loud posture) and propagates
+* `buildRequest`'s build errors (e.g. a Query without a hash key) for the
+* caller to surface as a note.
+*/
+function emitQueryProgram(config, format) {
+	if (config.operation !== "Query" && config.operation !== "Scan") throw new Error("the query builder emits Query and Scan programs only");
+	const request = buildRequest(config);
+	switch (format) {
+		case "sdk": return {
+			ok: true,
+			code: emitSdkProgram(request, config.paginate === true)
+		};
+		case "cli": return {
+			ok: true,
+			code: emitCliProgram(request, config.paginate === true)
+		};
+		case "boto3": return {
+			ok: true,
+			code: emitBoto3Program(request, config.paginate === true)
+		};
+		case "partiql": {
+			const result = emitPartiql(request);
+			return result.ok ? {
+				ok: true,
+				code: result.statement
+			} : result;
+		}
+		case "java": return {
+			ok: true,
+			code: emitJavaProgram(request, config.paginate === true)
+		};
+		case "go": return {
+			ok: true,
+			code: emitGoProgram(request, config.paginate === true)
+		};
+		case "dotnet": return {
+			ok: true,
+			code: emitDotnetProgram(request, config.paginate === true)
+		};
+		case "ddbtoolbox": return {
+			ok: true,
+			code: emitDdbToolboxProgram(request, config.paginate === true)
+		};
+	}
+}
+function emitSdkProgram(request, paginate) {
+	const command = sdkV3CommandName(request.operation);
+	const header = [
+		`import { DynamoDBClient, ${command} } from "@aws-sdk/client-dynamodb";`,
+		"",
+		"const client = new DynamoDBClient({});",
+		""
+	];
+	if (!paginate) {
+		const params$1 = renderJsValue(buildSdkV3Params(request), 1);
+		return [
+			...header,
+			"const response = await client.send(",
+			`  new ${command}(${params$1})`,
+			");",
+			"",
+			"console.log(response.Items);"
+		].join("\n");
+	}
+	const { ExclusiveStartKey: startKey,...params } = buildSdkV3Params(request);
+	const seed = startKey === void 0 ? ";" : ` = ${renderJsValue(startKey)};`;
+	return [
+		...header,
+		`const params = ${renderJsValue(params)};`,
+		"",
+		"const items = [];",
+		`let lastEvaluatedKey${seed}`,
+		"do {",
+		"  const page = await client.send(",
+		`    new ${command}({ ...params, ExclusiveStartKey: lastEvaluatedKey })`,
+		"  );",
+		"  items.push(...(page.Items ?? []));",
+		"  lastEvaluatedKey = page.LastEvaluatedKey;",
+		"} while (lastEvaluatedKey);",
+		"",
+		"console.log(items);"
+	].join("\n");
+}
+function emitCliProgram(request, paginate) {
+	const command = emitCli(request);
+	if (paginate) return ["# The AWS CLI auto-paginates: it follows LastEvaluatedKey and merges all pages.", command].join("\n");
+	return `${command} \\\n  --no-paginate`;
+}
+function emitBoto3Program(request, paginate) {
+	const method = boto3MethodName(request.operation);
+	const params = buildSdkV3Params(request);
+	const imports = hasBinaryValue(request) ? ["import base64", "import boto3"] : ["import boto3"];
+	const paramLines = Object.entries(params).map(([key, value]) => `    ${JSON.stringify(key)}: ${renderPyValue(value)},`);
+	const header = [
+		...imports,
+		"",
+		"client = boto3.client(\"dynamodb\")",
+		""
+	];
+	if (!paginate) return [
+		...header,
+		"params = {",
+		...paramLines,
+		"}",
+		"",
+		`response = client.${method}(**params)`,
+		"",
+		"print(response[\"Items\"])"
+	].join("\n");
+	return [
+		...header,
+		"params = {",
+		...paramLines,
+		"}",
+		"",
+		"items = []",
+		"while True:",
+		`    response = client.${method}(**params)`,
+		"    items.extend(response[\"Items\"])",
+		"    if \"LastEvaluatedKey\" not in response:",
+		"        break",
+		"    params[\"ExclusiveStartKey\"] = response[\"LastEvaluatedKey\"]",
+		"",
+		"print(items)"
+	].join("\n");
+}
+function emitJavaProgram(request, paginate) {
+	const requestClass = javaRequestClassName(request.operation);
+	const responseClass = requestClass.replace(/Request$/, "Response");
+	const method = javaClientMethodName(request.operation);
+	const binary = hasBinaryValue(request);
+	const usesAvMap = paginate || request.key !== void 0 || request.typedValues !== void 0 || request.exclusiveStartKey !== void 0;
+	const javaUtil = [
+		...paginate ? ["java.util.ArrayList", "java.util.List"] : [],
+		...binary ? ["java.util.Base64"] : [],
+		...usesAvMap || request.names ? ["java.util.Map"] : []
+	];
+	const sdk = [
+		...binary ? ["software.amazon.awssdk.core.SdkBytes"] : [],
+		"software.amazon.awssdk.services.dynamodb.DynamoDbClient",
+		...usesAvMap ? ["software.amazon.awssdk.services.dynamodb.model.AttributeValue"] : [],
+		`software.amazon.awssdk.services.dynamodb.model.${requestClass}`,
+		`software.amazon.awssdk.services.dynamodb.model.${responseClass}`
+	];
+	const header = [
+		...[...javaUtil, ...sdk].map((i) => `import ${i};`),
+		"",
+		"public class Main {",
+		"    public static void main(String[] args) {",
+		"        DynamoDbClient client = DynamoDbClient.create();",
+		""
+	];
+	const footer = ["    }", "}"];
+	if (!paginate) return [
+		...header,
+		`        ${requestClass} request = ${renderJavaRequestBuilder(request, "        ")};`,
+		"",
+		`        ${responseClass} response = client.${method}(request);`,
+		"        System.out.println(response.items());",
+		...footer
+	].join("\n");
+	const { exclusiveStartKey: startKey,...rest } = request;
+	const stripped = {
+		...rest,
+		config: request.config
+	};
+	const seed = startKey === void 0 ? "        Map<String, AttributeValue> lastEvaluatedKey = null;" : `        Map<String, AttributeValue> lastEvaluatedKey = ${renderJavaAvMap(startKey, "        ")};`;
+	return [
+		...header,
+		"        List<Map<String, AttributeValue>> items = new ArrayList<>();",
+		seed,
+		"        do {",
+		`            ${requestClass} request = ${renderJavaRequestBuilder(stripped, "            ", [".exclusiveStartKey(lastEvaluatedKey)"])};`,
+		`            ${responseClass} response = client.${method}(request);`,
+		"            items.addAll(response.items());",
+		"            lastEvaluatedKey = response.hasLastEvaluatedKey() ? response.lastEvaluatedKey() : null;",
+		"        } while (lastEvaluatedKey != null);",
+		"",
+		"        System.out.println(items);",
+		...footer
+	].join("\n");
+}
+function emitGoProgram(request, paginate) {
+	const inputType = goInputTypeName(request.operation);
+	const method = goClientMethodName(request.operation);
+	const header = [
+		"package main",
+		"",
+		"import (",
+		...[
+			"	\"context\"",
+			"	\"fmt\"",
+			"	\"log\"",
+			"",
+			"	\"github.com/aws/aws-sdk-go-v2/aws\"",
+			"	\"github.com/aws/aws-sdk-go-v2/config\"",
+			"	\"github.com/aws/aws-sdk-go-v2/service/dynamodb\"",
+			...goUsesTypes(request) || paginate ? ["	\"github.com/aws/aws-sdk-go-v2/service/dynamodb/types\""] : []
+		],
+		")",
+		"",
+		"func main() {",
+		"	cfg, err := config.LoadDefaultConfig(context.TODO())",
+		"	if err != nil {",
+		"		log.Fatal(err)",
+		"	}",
+		"	client := dynamodb.NewFromConfig(cfg)",
+		"",
+		`\tinput := ${renderGoInput(request, "	")}`,
+		""
+	];
+	if (!paginate) return [
+		...header,
+		`\tresponse, err := client.${method}(context.TODO(), input)`,
+		"	if err != nil {",
+		"		log.Fatal(err)",
+		"	}",
+		"	fmt.Println(response.Items)",
+		"}"
+	].join("\n");
+	return [
+		...header,
+		`\tpaginator := dynamodb.New${inputType.replace(/Input$/, "")}Paginator(client, input)`,
+		"",
+		"	var items []map[string]types.AttributeValue",
+		"	for paginator.HasMorePages() {",
+		"		page, err := paginator.NextPage(context.TODO())",
+		"		if err != nil {",
+		"			log.Fatal(err)",
+		"		}",
+		"		items = append(items, page.Items...)",
+		"	}",
+		"	fmt.Println(items)",
+		"}"
+	].join("\n");
+}
+function emitDotnetProgram(request, paginate) {
+	const method = dotnetClientMethodName(request.operation);
+	const binary = hasBinaryValue(request);
+	const header = [
+		"using System;",
+		...paginate || request.key !== void 0 || request.names !== void 0 || request.typedValues !== void 0 || request.exclusiveStartKey !== void 0 ? ["using System.Collections.Generic;"] : [],
+		...binary ? ["using System.IO;"] : [],
+		"using Amazon.DynamoDBv2;",
+		"using Amazon.DynamoDBv2.Model;",
+		"",
+		"var client = new AmazonDynamoDBClient();",
+		""
+	];
+	if (!paginate) return [
+		...header,
+		`var request = ${renderCsRequest(request, "")};`,
+		"",
+		`var response = await client.${method}(request);`,
+		"Console.WriteLine(response.Items.Count);"
+	].join("\n");
+	const { exclusiveStartKey: startKey,...rest } = request;
+	const stripped = {
+		...rest,
+		config: request.config
+	};
+	const seed = startKey === void 0 ? "Dictionary<string, AttributeValue> lastEvaluatedKey = null;" : `Dictionary<string, AttributeValue> lastEvaluatedKey = ${renderCsAvMap(startKey, "")};`;
+	return [
+		...header,
+		`var request = ${renderCsRequest(stripped, "")};`,
+		"",
+		"var items = new List<Dictionary<string, AttributeValue>>();",
+		seed,
+		"do",
+		"{",
+		"    request.ExclusiveStartKey = lastEvaluatedKey;",
+		`    var response = await client.${method}(request);`,
+		"    items.AddRange(response.Items);",
+		"    lastEvaluatedKey = response.LastEvaluatedKey;",
+		"} while (lastEvaluatedKey != null && lastEvaluatedKey.Count > 0);",
+		"",
+		"Console.WriteLine(items.Count);"
+	].join("\n");
+}
+
+//#endregion
+exports.FILTER_OPERATORS = FILTER_OPERATORS;
+exports.KEY_OPERATORS = KEY_OPERATORS;
+exports.OPERATOR_BY_VALUE = OPERATOR_BY_VALUE;
+exports.SET_TYPES = SET_TYPES;
+exports.boto3MethodName = boto3MethodName;
+exports.buildFilterExpressions = buildFilterExpressions;
+exports.buildKeyConditionExpression = buildKeyConditionExpression;
+exports.buildKeyMap = buildKeyMap;
+exports.buildRequest = buildRequest;
+exports.buildSdkV3Params = buildSdkV3Params;
+exports.buildUpdateExpression = buildUpdateExpression;
+exports.dotnetClientMethodName = dotnetClientMethodName;
+exports.dotnetRequestClassName = dotnetRequestClassName;
+exports.elementType = elementType;
+exports.emitBoto3 = emitBoto3;
+exports.emitCli = emitCli;
+exports.emitDdbToolboxProgram = emitDdbToolboxProgram;
+exports.emitDotnet = emitDotnet;
+exports.emitGo = emitGo;
+exports.emitJava = emitJava;
+exports.emitPartiql = emitPartiql;
+exports.emitQueryProgram = emitQueryProgram;
+exports.emitSdkV3 = emitSdkV3;
+exports.getCompatibleComparisonOperators = getCompatibleComparisonOperators;
+exports.getCompatibleFilterOperators = getCompatibleFilterOperators;
+exports.goClientMethodName = goClientMethodName;
+exports.goInputTypeName = goInputTypeName;
+exports.hasBinaryValue = hasBinaryValue;
+exports.isSetType = isSetType;
+exports.javaClientMethodName = javaClientMethodName;
+exports.javaRequestClassName = javaRequestClassName;
+exports.makeTypedValue = makeTypedValue;
+exports.renderJsValue = renderJsValue;
+exports.renderPyValue = renderPyValue;
+exports.sdkV3CommandName = sdkV3CommandName;
+exports.typedMapToAvMap = typedMapToAvMap;
+exports.typedValueToAv = typedValueToAv;