dynamodb-reactive 0.1.21 → 0.2.1

package/dist/server.js

@@ -1,10 +1,30 @@
-import { SystemTableNames } from './chunk-ZAJA4KBE.js';
 import { DynamoDBClient, ExecuteStatementCommand } from '@aws-sdk/client-dynamodb';
-import { UpdateCommand, DeleteCommand, PutCommand, GetCommand, DynamoDBDocumentClient, QueryCommand } from '@aws-sdk/lib-dynamodb';
+import { GetCommand, PutCommand, DeleteCommand, DynamoDBDocumentClient, UpdateCommand, TransactWriteCommand, QueryCommand } from '@aws-sdk/lib-dynamodb';
+import { createHash, randomUUID } from 'crypto';
+import { z } from 'zod';
 import { unmarshall } from '@aws-sdk/util-dynamodb';
-import jsonpatch from 'fast-json-patch';
-import { debug, error, warn, info } from 'ag-common/dist/common/helpers/log';
+import { isDeepStrictEqual } from 'util';
 import { ApiGatewayManagementApiClient, PostToConnectionCommand, GoneException } from '@aws-sdk/client-apigatewaymanagementapi';
+import jsonpatch from 'fast-json-patch';
+
+// ../server/src/errors.ts
+var SafeRequestError = class extends Error {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "SafeRequestError";
+    this.statusCode = statusCode;
+  }
+};
+var InvalidInputError = class extends SafeRequestError {
+  constructor() {
+    super("Invalid input", 400);
+    this.name = "InvalidInputError";
+  }
+};
+function isSafeRequestError(error2) {
+  return error2 instanceof SafeRequestError;
+}
 
 // ../server/src/procedure.ts
 var ProcedureBuilder = class _ProcedureBuilder {
@@ -47,7 +67,7 @@ async function executeProcedure(procedure, ctx, rawInput) {
   if (procedure.inputSchema) {
     const parseResult = procedure.inputSchema.safeParse(rawInput);
     if (!parseResult.success) {
-      throw new Error(`Invalid input: ${parseResult.error.message}`);
+      throw new InvalidInputError();
     }
     input = parseResult.data;
   } else {
@@ -89,50 +109,10 @@ var Router = class {
     }
     return executeProcedure(procedure, ctx, input);
   }
-  /**
-   * Get all procedure paths in the router
-   */
-  getProcedurePaths() {
-    const paths = [];
-    function traverse(obj, prefix) {
-      if (typeof obj !== "object" || obj === null) return;
-      for (const [key, value] of Object.entries(obj)) {
-        const path = prefix ? `${prefix}.${key}` : key;
-        if (isProcedure(value)) {
-          paths.push(path);
-        } else {
-          traverse(value, path);
-        }
-      }
-    }
-    traverse(this.definition, "");
-    return paths;
-  }
-  /**
-   * Check if a path is a query procedure
-   */
-  isQuery(path) {
-    const procedure = this.getProcedure(path);
-    return procedure?.type === "query";
-  }
-  /**
-   * Check if a path is a mutation procedure
-   */
-  isMutation(path) {
-    const procedure = this.getProcedure(path);
-    return procedure?.type === "mutation";
-  }
 };
 function createRouter(definition) {
   return new Router(definition);
 }
-function mergeRouters(...routers) {
-  const merged = {};
-  for (const router of routers) {
-    Object.assign(merged, router.definition);
-  }
-  return new Router(merged);
-}
 
 // ../server/src/reactive.ts
 function initReactive() {
@@ -143,155 +123,346 @@ function initReactive() {
     }
   };
 }
-
-// ../server/src/partiql-builder.ts
-function conditionToPartiQL(condition, parameters) {
+var MAX_TRACKED_PREFIX_LENGTH = 64;
+var TABLE_WILDCARD_FIELD = "*";
+var DYNAMODB_PARTITION_KEY_MAX_BYTES = 2048;
+var DEPENDENCY_KEY_VERSION = "d1";
+var HASHED_DEPENDENCY_KEY_VERSION = "d1h";
+var DEBUG_PREVIEW_BYTES = 96;
+function isPlainMap(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function encodeStructuredValue(value, seen) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+      return `string:${JSON.stringify(value)}`;
+    case "number":
+      return `number:${Object.is(value, -0) ? "-0" : String(value)}`;
+    case "boolean":
+      return `boolean:${String(value)}`;
+    case "bigint":
+      return `bigint:${String(value)}`;
+    case "undefined":
+      return "undefined";
+    case "symbol":
+      return `symbol:${String(value.description)}`;
+    case "function":
+      return `function:${String(value)}`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    return `binary:${Buffer.from(
+      value.buffer,
+      value.byteOffset,
+      value.byteLength
+    ).toString("base64url")}`;
+  }
+  if (value instanceof ArrayBuffer) {
+    return `binary:${Buffer.from(value).toString("base64url")}`;
+  }
+  if (value instanceof Date) {
+    return `date:${Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString()}`;
+  }
+  if (seen.has(value)) return "circular";
+  seen.add(value);
+  let encoded;
+  if (Array.isArray(value)) {
+    encoded = `array:${JSON.stringify(
+      value.map((item) => encodeStructuredValue(item, seen))
+    )}`;
+  } else if (value instanceof Set) {
+    encoded = `set:${JSON.stringify(
+      [...value].map((item) => encodeStructuredValue(item, seen)).sort()
+    )}`;
+  } else if (isPlainMap(value)) {
+    encoded = `map:${JSON.stringify(
+      Object.keys(value).sort().map((key) => [key, encodeStructuredValue(value[key], seen)])
+    )}`;
+  } else {
+    encoded = `object:${Object.prototype.toString.call(value)}:${String(value)}`;
+  }
+  seen.delete(value);
+  return encoded;
+}
+function encodeDependencyValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "object" && isPlainMap(value)) return null;
+  return encodeStructuredValue(value, /* @__PURE__ */ new Set());
+}
+function wildcardDependency(tableName) {
+  return { tableName, fieldName: TABLE_WILDCARD_FIELD, fieldValue: "*" };
+}
+function extractFromCondition(tableName, condition) {
+  const dependencies = [];
   switch (condition.type) {
     case "comparison": {
-      parameters.push(condition.value);
-      return `"${condition.field}" ${condition.operator} ?`;
+      const fieldValue = encodeDependencyValue(condition.value);
+      if (condition.operator === "eq" && typeof condition.field === "string" && fieldValue !== null) {
+        dependencies.push({
+          tableName,
+          fieldName: condition.field,
+          fieldValue
+        });
+      }
+      return { dependencies, safe: dependencies.length === 1 };
     }
     case "function": {
-      if (condition.operator === "BETWEEN") {
-        parameters.push(condition.value);
-        parameters.push(condition.value2);
-        return `"${condition.field}" BETWEEN ? AND ?`;
-      }
-      if (condition.operator === "begins_with") {
-        parameters.push(condition.value);
-        return `begins_with("${condition.field}", ?)`;
-      }
-      if (condition.operator === "contains") {
-        parameters.push(condition.value);
-        return `contains("${condition.field}", ?)`;
+      if (condition.operator === "beginsWith" && typeof condition.field === "string" && typeof condition.value === "string" && condition.value.length > 0 && condition.value.length <= MAX_TRACKED_PREFIX_LENGTH) {
+        dependencies.push({
+          tableName,
+          fieldName: condition.field,
+          fieldValue: `prefix:${String(condition.value)}`
+        });
       }
-      throw new Error(`Unknown function operator: ${condition.operator}`);
+      return { dependencies, safe: dependencies.length === 1 };
     }
     case "logical": {
-      if (!condition.conditions || condition.conditions.length === 0) {
-        throw new Error(
-          "Logical condition requires at least one sub-condition"
-        );
+      if (condition.operator === "not" || !condition.conditions || condition.conditions.length === 0) {
+        return { dependencies, safe: false };
       }
-      if (condition.operator === "NOT") {
-        const subClause = conditionToPartiQL(
-          condition.conditions[0],
-          parameters
+      let safe = true;
+      for (const subCondition of condition.conditions) {
+        const extracted = extractFromCondition(
+          tableName,
+          subCondition
         );
-        return `NOT (${subClause})`;
+        dependencies.push(...extracted.dependencies);
+        safe &&= extracted.safe;
       }
-      const subClauses = condition.conditions.map(
-        (c) => conditionToPartiQL(c, parameters)
-      );
-      return `(${subClauses.join(` ${condition.operator} `)})`;
+      return { dependencies, safe };
     }
-    default:
-      throw new Error(`Unknown condition type: ${condition.type}`);
   }
+  return { dependencies, safe: false };
 }
-function buildSelectStatement(operation) {
-  const parameters = [];
-  let statement = `SELECT * FROM "${operation.tableName}"`;
-  if (operation.indexName) {
-    statement += `."${operation.indexName}"`;
+function extractDependencies(operation) {
+  const dependencies = [];
+  let safe = operation.filters.length > 0;
+  for (const filter of operation.filters) {
+    const extracted = extractFromCondition(operation.tableName, filter);
+    dependencies.push(...extracted.dependencies);
+    safe &&= extracted.safe;
   }
-  if (operation.filters.length > 0) {
-    const whereClauses = operation.filters.map(
-      (f) => conditionToPartiQL(f, parameters)
-    );
-    statement += ` WHERE ${whereClauses.join(" AND ")}`;
+  if (!safe) dependencies.push(wildcardDependency(operation.tableName));
+  const unique = /* @__PURE__ */ new Map();
+  for (const dependency of dependencies) {
+    unique.set(createDependencyKey(dependency), dependency);
   }
-  return { statement, parameters };
+  return [...unique.values()];
 }
-function buildInsertStatement(tableName, item) {
-  const parameters = [item];
-  const statement = `INSERT INTO "${tableName}" VALUE ?`;
-  return { statement, parameters };
+function createDependencyKey(dependency) {
+  const components = [
+    dependency.tableName,
+    dependency.fieldName,
+    dependency.fieldValue
+  ];
+  const encoded = components.map(
+    (component) => Buffer.from(component, "utf8").toString("base64url")
+  );
+  const key = `${DEPENDENCY_KEY_VERSION}#${encoded.join("#")}`;
+  if (Buffer.byteLength(key, "utf8") <= DYNAMODB_PARTITION_KEY_MAX_BYTES) {
+    return key;
+  }
+  const digest = createHash("sha256").update(key, "utf8").digest("hex");
+  const previews = components.map(
+    (component) => Buffer.from(utf8Preview(component), "utf8").toString("base64url")
+  );
+  return `${HASHED_DEPENDENCY_KEY_VERSION}#${digest}#${previews.join("#")}`;
 }
-function buildUpdateStatement(tableName, key, updates) {
-  const parameters = [];
-  const setClauses = [];
-  for (const [field, value] of Object.entries(updates)) {
-    if (field in key) continue;
-    setClauses.push(`"${field}" = ?`);
-    parameters.push(value);
-  }
-  if (setClauses.length === 0) {
-    throw new Error("No fields to update");
-  }
-  let statement = `UPDATE "${tableName}" SET ${setClauses.join(", ")}`;
-  const whereClauses = Object.entries(key).map(([field, value]) => {
-    parameters.push(value);
-    return `"${field}" = ?`;
-  });
-  statement += ` WHERE ${whereClauses.join(" AND ")}`;
-  return { statement, parameters };
+function utf8Preview(value) {
+  if (Buffer.byteLength(value, "utf8") <= DEBUG_PREVIEW_BYTES) return value;
+  let preview = "";
+  for (const character of value) {
+    if (Buffer.byteLength(`${preview}${character}`, "utf8") > DEBUG_PREVIEW_BYTES) {
+      break;
+    }
+    preview += character;
+  }
+  return `${preview}...`;
 }
-function buildDeleteStatement(tableName, key) {
-  const parameters = [];
-  const whereClauses = Object.entries(key).map(([field, value]) => {
-    parameters.push(value);
-    return `"${field}" = ?`;
-  });
-  const statement = `DELETE FROM "${tableName}" WHERE ${whereClauses.join(" AND ")}`;
-  return { statement, parameters };
+function parseDependencyKey(key) {
+  const parts = key.split("#");
+  const decode = (encoded) => {
+    const buffer = Buffer.from(encoded, "base64url");
+    return buffer.toString("base64url") === encoded ? buffer.toString("utf8") : null;
+  };
+  if (parts[0] === DEPENDENCY_KEY_VERSION && parts.length === 4) {
+    const decoded = parts.slice(1).map(decode);
+    if (decoded.some((component) => component === null)) return null;
+    return {
+      tableName: decoded[0],
+      fieldName: decoded[1],
+      fieldValue: decoded[2]
+    };
+  }
+  if (parts[0] === HASHED_DEPENDENCY_KEY_VERSION && parts.length === 5 && /^[a-f0-9]{64}$/.test(parts[1])) {
+    const decoded = parts.slice(2).map(decode);
+    if (decoded.some((component) => component === null)) return null;
+    return {
+      tableName: decoded[0],
+      fieldName: decoded[1],
+      fieldValue: `${decoded[2]} [sha256:${parts[1]}]`
+    };
+  }
+  return null;
 }
-function buildGetStatement(tableName, key) {
-  const parameters = [];
-  const whereClauses = Object.entries(key).map(([field, value]) => {
-    parameters.push(value);
-    return `"${field}" = ?`;
-  });
-  const statement = `SELECT * FROM "${tableName}" WHERE ${whereClauses.join(" AND ")}`;
-  return { statement, parameters };
+function extractAffectedKeys(tableName, item) {
+  const keys = /* @__PURE__ */ new Set([
+    createDependencyKey(wildcardDependency(tableName))
+  ]);
+  const visit = (fieldName, fieldValue) => {
+    if (fieldValue !== null && fieldValue !== void 0) {
+      const encodedValue = encodeDependencyValue(fieldValue);
+      if (encodedValue !== null) {
+        keys.add(
+          createDependencyKey({
+            tableName,
+            fieldName,
+            fieldValue: encodedValue
+          })
+        );
+      }
+      if (typeof fieldValue === "string") {
+        const maxPrefixLen = Math.min(
+          fieldValue.length,
+          MAX_TRACKED_PREFIX_LENGTH
+        );
+        for (let i = 1; i <= maxPrefixLen; i++) {
+          keys.add(
+            createDependencyKey({
+              tableName,
+              fieldName,
+              fieldValue: `prefix:${fieldValue.substring(0, i)}`
+            })
+          );
+        }
+      }
+      if (typeof fieldValue === "object" && isPlainMap(fieldValue)) {
+        for (const [nestedName, nestedValue2] of Object.entries(fieldValue)) {
+          visit(`${fieldName}.${nestedName}`, nestedValue2);
+        }
+      }
+    }
+  };
+  for (const [fieldName, fieldValue] of Object.entries(item)) {
+    visit(fieldName, fieldValue);
+  }
+  return [...keys];
+}
+function operationToQueryMetadata(operation) {
+  return {
+    planVersion: 1,
+    tableName: operation.tableName,
+    indexName: operation.indexName,
+    indexPkField: operation.indexPkField,
+    indexSkField: operation.indexSkField,
+    filterConditions: operation.filters,
+    ...operation.sortField && operation.sortOrder ? { sortField: operation.sortField, sortOrder: operation.sortOrder } : {},
+    limit: operation.limit
+  };
 }
+var DependencyTracker = class {
+  operations = [];
+  /**
+   * Track a query operation
+   */
+  track(operation, result) {
+    this.operations.push({
+      operation,
+      resultReference: result,
+      resultSnapshot: structuredClone(result)
+    });
+  }
+  /**
+   * Get all tracked operations
+   */
+  getOperations() {
+    return this.operations.map(({ operation }) => operation);
+  }
+  /**
+   * Extract all dependencies from tracked operations
+   */
+  extractAll() {
+    const dependencies = [];
+    for (const { operation } of this.operations) {
+      dependencies.push(...extractDependencies(operation));
+    }
+    return dependencies;
+  }
+  /**
+   * Get query metadata for the first tracked operation.
+   * Used for storing subscription state.
+   */
+  getQueryMetadata() {
+    if (this.operations.length === 0) return null;
+    return operationToQueryMetadata(this.operations[0].operation);
+  }
+  getCapturedResult() {
+    if (this.operations.length !== 1) return null;
+    return {
+      reference: this.operations[0].resultReference,
+      snapshot: structuredClone(this.operations[0].resultSnapshot)
+    };
+  }
+};
 
 // ../server/src/query-builder.ts
-function createCondition(type, operator, field, value, value2) {
-  return { type, operator, field, value, value2 };
-}
 var FilterBuilderImpl = class {
   eq(field, value) {
-    return createCondition("comparison", "=", field.fieldName, value);
+    return { type: "comparison", operator: "eq", field: field.fieldName, value };
   }
   ne(field, value) {
-    return createCondition("comparison", "<>", field.fieldName, value);
+    return { type: "comparison", operator: "ne", field: field.fieldName, value };
   }
   gt(field, value) {
-    return createCondition("comparison", ">", field.fieldName, value);
+    return { type: "comparison", operator: "gt", field: field.fieldName, value };
   }
   gte(field, value) {
-    return createCondition("comparison", ">=", field.fieldName, value);
+    return { type: "comparison", operator: "gte", field: field.fieldName, value };
   }
   lt(field, value) {
-    return createCondition("comparison", "<", field.fieldName, value);
+    return { type: "comparison", operator: "lt", field: field.fieldName, value };
   }
   lte(field, value) {
-    return createCondition("comparison", "<=", field.fieldName, value);
+    return { type: "comparison", operator: "lte", field: field.fieldName, value };
   }
   between(field, lower, upper) {
-    return createCondition(
-      "function",
-      "BETWEEN",
-      field.fieldName,
-      lower,
-      upper
-    );
+    return {
+      type: "function",
+      operator: "between",
+      field: field.fieldName,
+      value: lower,
+      value2: upper
+    };
   }
   beginsWith(field, prefix) {
-    return createCondition("function", "begins_with", field.fieldName, prefix);
+    return {
+      type: "function",
+      operator: "beginsWith",
+      field: field.fieldName,
+      value: prefix
+    };
   }
   contains(field, substring) {
-    return createCondition("function", "contains", field.fieldName, substring);
+    return {
+      type: "function",
+      operator: "contains",
+      field: field.fieldName,
+      value: substring
+    };
   }
   and(...conditions) {
-    return { type: "logical", operator: "AND", conditions };
+    return { type: "logical", operator: "and", conditions };
   }
   or(...conditions) {
-    return { type: "logical", operator: "OR", conditions };
+    return { type: "logical", operator: "or", conditions };
   }
   not(condition) {
-    return { type: "logical", operator: "NOT", conditions: [condition] };
+    return { type: "logical", operator: "not", conditions: [condition] };
   }
 };
 var QueryBuilderImpl = class {
@@ -299,8 +470,8 @@ var QueryBuilderImpl = class {
   filters = [];
   indexName;
   limit;
-  startKey;
   ascending = true;
+  sortRequested = false;
   executor;
   operationTracker;
   constructor(table, executor, operationTracker) {
@@ -315,75 +486,422 @@ var QueryBuilderImpl = class {
     return this;
   }
   useIndex(indexName) {
+    if (!this.table.indexes[indexName]) {
+      throw new Error(`Unknown index: ${indexName}`);
+    }
     this.indexName = indexName;
     return this;
   }
   take(limit) {
+    if (!Number.isInteger(limit) || limit <= 0) {
+      throw new Error("take(limit) requires a positive integer");
+    }
     this.limit = limit;
     return this;
   }
-  startFrom(key) {
-    this.startKey = key;
-    return this;
-  }
   sortAscending() {
     this.ascending = true;
+    this.sortRequested = true;
     return this;
   }
   sortDescending() {
     this.ascending = false;
+    this.sortRequested = true;
     return this;
   }
   async execute() {
-    const operation = {
-      tableName: this.table.tableName,
-      filters: this.filters,
-      indexName: this.indexName,
-      pkField: this.table.pk,
-      skField: this.table.sk,
-      sortField: this.table.sk,
-      // Default sort by SK if available
-      sortOrder: this.ascending ? "asc" : "desc",
-      limit: this.limit
-    };
-    if (this.operationTracker) {
-      this.operationTracker(operation);
-    }
-    const options = {
-      limit: this.limit,
-      startKey: this.startKey,
-      ascending: this.ascending
-    };
-    return this.executor(operation, options);
+    const operation = this.getOperation();
+    const result = await this.executor(operation);
+    this.operationTracker?.(operation, result);
+    return result;
   }
   /**
    * Get the current operation without executing
    * Used for dependency extraction
    */
   getOperation() {
+    const index = this.indexName ? this.table.indexes[this.indexName] : void 0;
+    const selectedSortField = index ? index.sk : this.table.sk;
+    const sortField = this.sortRequested ? selectedSortField : void 0;
+    if (this.sortRequested && !sortField) {
+      throw new Error("Sorting requires a table or index sort key");
+    }
     return {
       tableName: this.table.tableName,
       filters: this.filters,
-      indexName: this.indexName,
-      pkField: this.table.pk,
-      skField: this.table.sk,
-      sortField: this.table.sk,
-      sortOrder: this.ascending ? "asc" : "desc",
+      indexName: index?.name,
+      indexPkField: index?.pk,
+      indexSkField: index?.sk,
+      ...sortField ? { sortField, sortOrder: this.ascending ? "asc" : "desc" } : {},
       limit: this.limit
     };
   }
 };
-function createFilterBuilder() {
-  return new FilterBuilderImpl();
+var FilterConditionSchema = z.lazy(() => {
+  const comparison = z.object({
+    type: z.literal("comparison"),
+    operator: z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+    field: z.string().min(1),
+    value: z.unknown()
+  }).strict();
+  const queryFunction = z.union([
+    z.object({
+      type: z.literal("function"),
+      operator: z.literal("between"),
+      field: z.string().min(1),
+      value: z.unknown(),
+      value2: z.unknown()
+    }).strict(),
+    z.object({
+      type: z.literal("function"),
+      operator: z.enum(["beginsWith", "contains"]),
+      field: z.string().min(1),
+      value: z.unknown()
+    }).strict()
+  ]);
+  const logical = z.object({
+    type: z.literal("logical"),
+    operator: z.enum(["and", "or", "not"]),
+    conditions: z.array(FilterConditionSchema).min(1)
+  }).strict().superRefine((condition, context) => {
+    if (condition.operator === "not" && condition.conditions.length !== 1) {
+      context.addIssue({
+        code: "custom",
+        path: ["conditions"],
+        message: "not requires exactly one condition"
+      });
+    }
+  });
+  return z.union([comparison, queryFunction, logical]);
+});
+var QueryMetadataSchema = z.object({
+  planVersion: z.literal(1),
+  tableName: z.string().min(1),
+  indexName: z.string().min(1).optional(),
+  indexPkField: z.string().min(1).optional(),
+  indexSkField: z.string().min(1).optional(),
+  filterConditions: z.array(FilterConditionSchema),
+  sortField: z.string().min(1).optional(),
+  sortOrder: z.enum(["asc", "desc"]).optional(),
+  limit: z.number().int().positive().optional()
+}).strict().superRefine((metadata, context) => {
+  if (metadata.indexName && !metadata.indexPkField) {
+    context.addIssue({
+      code: "custom",
+      path: ["indexPkField"],
+      message: "Index metadata requires its partition key field"
+    });
+  }
+  if (!metadata.indexName && (metadata.indexPkField || metadata.indexSkField)) {
+    context.addIssue({
+      code: "custom",
+      path: ["indexName"],
+      message: "Index key fields require an index name"
+    });
+  }
+  if (Boolean(metadata.sortField) !== Boolean(metadata.sortOrder)) {
+    context.addIssue({
+      code: "custom",
+      path: ["sortOrder"],
+      message: "Sort field and order must be specified together"
+    });
+  }
+});
+var DeliveryVersionSchema = z.object({
+  generation: z.number().int().nonnegative(),
+  fromVersion: z.number().int().nonnegative(),
+  toVersion: z.number().int().positive(),
+  messageId: z.string().min(1)
+});
+var PendingDeliverySchema = z.discriminatedUnion("type", [
+  DeliveryVersionSchema.extend({
+    type: z.literal("patch"),
+    patches: z.array(
+      z.object({
+        op: z.enum(["add", "remove", "replace", "move", "copy", "test"]),
+        path: z.string(),
+        value: z.unknown().optional(),
+        from: z.string().optional()
+      })
+    )
+  }),
+  DeliveryVersionSchema.extend({
+    type: z.literal("resync")
+  }).strict()
+]);
+var SystemSchemas = {
+  /**
+   * ReactiveConnectionsV2 - Tracks active WebSocket connections
+   */
+  connections: z.object({
+    connectionId: z.string(),
+    status: z.enum(["open", "closed"]),
+    context: z.record(z.string(), z.unknown()).optional(),
+    authorizerContext: z.record(z.string(), z.unknown()).optional(),
+    requestIdentity: z.record(z.string(), z.unknown()).optional(),
+    connectedAt: z.number(),
+    ttl: z.number()
+  }),
+  /**
+   * ReactiveDependenciesV2 - The inverted index for O(1) lookups
+   */
+  dependencies: z.object({
+    pk: z.string(),
+    // Versioned encoded dependency key
+    sk: z.string(),
+    // ConnectionID#SubscriptionID
+    connectionId: z.string(),
+    subscriptionId: z.string(),
+    tableName: z.string(),
+    fieldName: z.string(),
+    fieldValue: z.string(),
+    generation: z.number().int().nonnegative(),
+    registrationId: z.string().min(1),
+    ttl: z.number()
+  }),
+  /**
+   * ReactiveConnectionQueriesV2 - Stores subscription state for diffing
+   */
+  queries: z.object({
+    pk: z.string(),
+    // ConnectionID
+    sk: z.string(),
+    // SubscriptionID
+    connectionId: z.string(),
+    subscriptionId: z.string(),
+    status: z.enum(["registering", "active", "cancelled", "faulted"]),
+    generation: z.number().int().nonnegative(),
+    registrationId: z.string().min(1),
+    queryMetadata: QueryMetadataSchema,
+    lastResult: z.array(z.unknown()),
+    dependencies: z.array(z.string()),
+    version: z.number().int().nonnegative(),
+    pendingDelivery: PendingDeliverySchema.optional(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+    ttl: z.number()
+  })
+};
+var SystemTableNames = {
+  connections: "ReactiveConnectionsV2",
+  dependencies: "ReactiveDependenciesV2",
+  queries: "ReactiveConnectionQueriesV2"
+};
+var InvalidQueryMetadataError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidQueryMetadataError";
+  }
+};
+function attributeValue(value) {
+  if (value === null) return { NULL: true };
+  if (value === void 0) {
+    throw new InvalidQueryMetadataError("Query parameter values are required");
+  }
+  if (typeof value === "string") return { S: value };
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new InvalidQueryMetadataError("Query values must be finite numbers");
+    }
+    return { N: String(value) };
+  }
+  if (typeof value === "boolean") return { BOOL: value };
+  if (value instanceof Uint8Array) return { B: value };
+  if (value instanceof Set) {
+    const values = [...value];
+    if (values.length === 0) {
+      throw new InvalidQueryMetadataError("Query sets must not be empty");
+    }
+    if (values.every((item) => typeof item === "string")) {
+      return { SS: values };
+    }
+    if (values.every((item) => typeof item === "number")) {
+      if (values.some((item) => !Number.isFinite(item))) {
+        throw new InvalidQueryMetadataError("Query values must be finite numbers");
+      }
+      return { NS: values.map(String) };
+    }
+    if (values.every((item) => item instanceof Uint8Array)) {
+      return { BS: values };
+    }
+    throw new InvalidQueryMetadataError(
+      "Query sets must contain one supported DynamoDB scalar type"
+    );
+  }
+  if (Array.isArray(value)) return { L: value.map(attributeValue) };
+  if (typeof value === "object") {
+    return {
+      M: Object.fromEntries(
+        Object.entries(value).map(([key, item]) => [
+          key,
+          attributeValue(item)
+        ])
+      )
+    };
+  }
+  throw new InvalidQueryMetadataError(
+    `Unsupported query value type: ${typeof value}`
+  );
+}
+function quoteIdentifier(identifier) {
+  if (!identifier) {
+    throw new InvalidQueryMetadataError("Identifier must not be empty");
+  }
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function quotePath(path) {
+  if (!path || path.split(".").some((part) => !part)) {
+    throw new InvalidQueryMetadataError(`Invalid field path: ${path}`);
+  }
+  return path.split(".").map(quoteIdentifier).join(".");
+}
+function compileCondition(condition, parameters) {
+  if (condition.type === "comparison" && condition.field) {
+    const operators = {
+      eq: "=",
+      ne: "<>",
+      gt: ">",
+      gte: ">=",
+      lt: "<",
+      lte: "<="
+    };
+    const operator = operators[condition.operator];
+    if (!operator) {
+      throw new InvalidQueryMetadataError(
+        `Unsupported comparison operator: ${condition.operator}`
+      );
+    }
+    parameters.push(attributeValue(condition.value));
+    return `${quotePath(condition.field)} ${operator} ?`;
+  }
+  if (condition.type === "function" && condition.field) {
+    if (condition.operator === "between") {
+      parameters.push(attributeValue(condition.value));
+      parameters.push(attributeValue(condition.value2));
+      return `${quotePath(condition.field)} BETWEEN ? AND ?`;
+    }
+    if (condition.operator === "beginsWith" || condition.operator === "contains") {
+      parameters.push(attributeValue(condition.value));
+      const name = condition.operator === "beginsWith" ? "begins_with" : "contains";
+      return `${name}(${quotePath(condition.field)}, ?)`;
+    }
+    throw new InvalidQueryMetadataError(
+      `Unsupported function operator: ${condition.operator}`
+    );
+  }
+  if (condition.type === "logical" && condition.conditions?.length) {
+    if (condition.operator === "not") {
+      if (condition.conditions.length !== 1) {
+        throw new InvalidQueryMetadataError("NOT requires exactly one condition");
+      }
+      return `NOT (${compileCondition(condition.conditions[0], parameters)})`;
+    }
+    if (condition.operator === "and" || condition.operator === "or") {
+      const operator = condition.operator.toUpperCase();
+      return `(${condition.conditions.map((item) => compileCondition(item, parameters)).join(` ${operator} `)})`;
+    }
+  }
+  throw new InvalidQueryMetadataError("Malformed query filter condition");
+}
+function parseQueryMetadata(metadata) {
+  const parsed = QueryMetadataSchema.safeParse(metadata);
+  if (!parsed.success) {
+    throw new InvalidQueryMetadataError(
+      `Invalid query metadata: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+function compileQueryMetadata(metadataInput, nextToken) {
+  const metadata = parseQueryMetadata(metadataInput);
+  const parameters = [];
+  let statement = `SELECT * FROM ${quoteIdentifier(metadata.tableName)}`;
+  const predicates = [];
+  if (metadata.indexPkField) {
+    predicates.push(`${quotePath(metadata.indexPkField)} IS NOT MISSING`);
+  }
+  if (metadata.indexSkField) {
+    predicates.push(`${quotePath(metadata.indexSkField)} IS NOT MISSING`);
+  }
+  if (metadata.filterConditions.length) {
+    predicates.push(
+      ...metadata.filterConditions.map(
+        (condition) => compileCondition(condition, parameters)
+      )
+    );
+  }
+  if (predicates.length) statement += ` WHERE ${predicates.join(" AND ")}`;
+  return {
+    Statement: statement,
+    ConsistentRead: true,
+    ...parameters.length ? { Parameters: parameters } : {},
+    ...nextToken ? { NextToken: nextToken } : {}
+  };
+}
+function nestedValue(item, path) {
+  return path.split(".").reduce((value, part) => {
+    if (!value || typeof value !== "object") return void 0;
+    return value[part];
+  }, item);
+}
+function compareValues(left, right) {
+  if (left === right) return 0;
+  if (typeof left === "number" && typeof right === "number") return left - right;
+  if (typeof left === "string" && typeof right === "string") {
+    return Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8"));
+  }
+  if (left instanceof Uint8Array && right instanceof Uint8Array) {
+    return Buffer.compare(Buffer.from(left), Buffer.from(right));
+  }
+  throw new InvalidQueryMetadataError(
+    "Sorted query fields must contain one consistent DynamoDB key type"
+  );
+}
+async function executeQueryMetadata(client, metadataInput) {
+  const metadata = parseQueryMetadata(metadataInput);
+  const items = [];
+  let nextToken;
+  const seenTokens = /* @__PURE__ */ new Set();
+  do {
+    const response = await client.send(
+      new ExecuteStatementCommand(compileQueryMetadata(metadata, nextToken))
+    );
+    items.push(
+      ...(response.Items ?? []).map(
+        (item) => unmarshall(item)
+      )
+    );
+    nextToken = response.NextToken;
+    if (nextToken && seenTokens.has(nextToken)) {
+      throw new Error("DynamoDB returned a repeated pagination token");
+    }
+    if (nextToken) seenTokens.add(nextToken);
+    if (metadata.limit !== void 0 && !metadata.sortField && items.length >= metadata.limit) {
+      break;
+    }
+  } while (nextToken);
+  if (metadata.sortField) {
+    items.sort((left, right) => {
+      const result = compareValues(
+        nestedValue(left, metadata.sortField),
+        nestedValue(right, metadata.sortField)
+      );
+      return metadata.sortOrder === "desc" ? -result : result;
+    });
+  }
+  return metadata.limit === void 0 ? items : items.slice(0, metadata.limit);
 }
 
 // ../server/src/db-context.ts
-function createDocClient(config) {
+var MAX_CONDITION_EXPRESSION_BYTES = 4 * 1024;
+var MAX_EXPRESSION_VARIABLE_BYTES = 2 * 1024 * 1024;
+var MAX_CONDITION_OPERATORS = 300;
+function createClients(config) {
   const client = config.client ?? new DynamoDBClient({
     region: config.region ?? process.env.AWS_REGION ?? "us-east-1",
     endpoint: config.endpoint
   });
-  return DynamoDBDocumentClient.from(client, {
+  const docClient = config.docClient ?? DynamoDBDocumentClient.from(client, {
     marshallOptions: {
       removeUndefinedValues: true,
       convertEmptyValues: false
@@ -392,43 +910,15 @@ function createDocClient(config) {
       wrapNumbers: false
     }
   });
-}
-function toAttributeValue(value) {
-  if (typeof value === "string") return { S: value };
-  if (typeof value === "number") return { N: String(value) };
-  if (typeof value === "boolean") return { BOOL: value };
-  if (value === null || value === void 0) return { NULL: true };
-  if (Array.isArray(value)) {
-    return { L: value.map(toAttributeValue) };
-  }
-  if (typeof value === "object") {
-    const m = {};
-    for (const [k, v] of Object.entries(value)) {
-      m[k] = toAttributeValue(v);
-    }
-    return { M: m };
-  }
-  return { S: String(value) };
-}
-async function executePartiQL(docClient, statement) {
-  const command = new ExecuteStatementCommand({
-    Statement: statement.statement,
-    Parameters: statement.parameters.map(toAttributeValue)
-  });
-  const response = await docClient.send(command);
-  return (response.Items ?? []).map(
-    (item) => unmarshall(item)
-  );
+  return { client, docClient };
 }
 function createDbContext(config, dependencyTracker) {
-  const docClient = createDocClient(config);
-  async function executeQuery(operation, options) {
-    const statement = buildSelectStatement(operation);
-    const items = await executePartiQL(docClient, statement);
-    if (options.limit && items.length > options.limit) {
-      return items.slice(0, options.limit);
-    }
-    return items;
+  const { client, docClient } = createClients(config);
+  async function executeQuery(operation) {
+    return executeQueryMetadata(
+      client,
+      operationToQueryMetadata(operation)
+    );
   }
   return {
     query(table) {
@@ -441,16 +931,17 @@ function createDbContext(config, dependencyTracker) {
     async get(table, key) {
       const command = new GetCommand({
         TableName: table.tableName,
-        Key: key
+        Key: key,
+        ConsistentRead: true
       });
       const response = await docClient.send(command);
       return response.Item ? response.Item : null;
     },
     async put(table, item) {
-      table.validate(item);
+      const parsedItem = table.validate(item);
       const command = new PutCommand({
         TableName: table.tableName,
-        Item: item
+        Item: parsedItem
       });
       await docClient.send(command);
     },
@@ -462,528 +953,698 @@ function createDbContext(config, dependencyTracker) {
       await docClient.send(command);
     },
     async update(table, key, updates) {
-      const updateExpressions = [];
+      const currentResponse = await docClient.send(
+        new GetCommand({
+          TableName: table.tableName,
+          Key: key,
+          ConsistentRead: true
+        })
+      );
+      const current = currentResponse.Item;
+      if (!current) throw new Error("Item not found");
+      const parsed = table.validate({
+        ...current,
+        ...updates,
+        ...key
+      });
+      const expected = current;
+      const fields = [
+        .../* @__PURE__ */ new Set([
+          ...table.getFieldNames().map(String),
+          ...Object.keys(expected)
+        ])
+      ].sort();
+      const conditions = [];
       const expressionAttributeNames = {};
       const expressionAttributeValues = {};
-      let i = 0;
-      for (const [field, value] of Object.entries(updates)) {
-        if (field in key) continue;
+      for (const [i, field] of fields.entries()) {
         const nameKey = `#f${i}`;
-        const valueKey = `:v${i}`;
-        updateExpressions.push(`${nameKey} = ${valueKey}`);
         expressionAttributeNames[nameKey] = field;
-        expressionAttributeValues[valueKey] = value;
-        i++;
-      }
-      if (updateExpressions.length === 0) {
-        const current = await this.get(table, key);
-        if (!current) {
-          throw new Error("Item not found");
+        if (Object.prototype.hasOwnProperty.call(expected, field)) {
+          const valueKey = `:e${i}`;
+          conditions.push(`${nameKey} = ${valueKey}`);
+          expressionAttributeValues[valueKey] = expected[field];
+        } else {
+          conditions.push(`attribute_not_exists(${nameKey})`);
         }
-        return current;
       }
-      const command = new UpdateCommand({
+      const conditionExpression = conditions.join(" AND ");
+      const variableBytes = Buffer.byteLength(
+        JSON.stringify({
+          names: expressionAttributeNames,
+          values: expressionAttributeValues
+        }),
+        "utf8"
+      );
+      if (Buffer.byteLength(conditionExpression, "utf8") > MAX_CONDITION_EXPRESSION_BYTES || conditions.length > MAX_CONDITION_OPERATORS || variableBytes > MAX_EXPRESSION_VARIABLE_BYTES) {
+        throw new Error(
+          "Item is too complex to update with a safe compare-and-swap"
+        );
+      }
+      const command = new PutCommand({
         TableName: table.tableName,
-        Key: key,
-        UpdateExpression: `SET ${updateExpressions.join(", ")}`,
-        ExpressionAttributeNames: expressionAttributeNames,
-        ExpressionAttributeValues: expressionAttributeValues,
-        ReturnValues: "ALL_NEW"
+        Item: parsed,
+        ConditionExpression: conditionExpression,
+        ...Object.keys(expressionAttributeNames).length ? { ExpressionAttributeNames: expressionAttributeNames } : {},
+        ...Object.keys(expressionAttributeValues).length ? { ExpressionAttributeValues: expressionAttributeValues } : {}
       });
-      const response = await docClient.send(command);
-      return response.Attributes;
+      await docClient.send(command);
+      return parsed;
     }
   };
 }
 
-// ../server/src/dependency-extractor.ts
-function extractFromCondition(tableName, condition, indexName) {
-  const dependencies = [];
-  switch (condition.type) {
-    case "comparison": {
-      if (condition.operator === "=" && condition.field && condition.value !== void 0) {
-        dependencies.push({
-          tableName,
-          fieldName: condition.field,
-          fieldValue: String(condition.value),
-          indexName
-        });
-      }
-      break;
-    }
-    case "function": {
-      if (condition.operator === "begins_with" && condition.field && condition.value) {
-        dependencies.push({
-          tableName,
-          fieldName: condition.field,
-          fieldValue: `prefix:${String(condition.value)}`,
-          indexName
-        });
-      }
-      break;
-    }
-    case "logical": {
-      if (condition.conditions) {
-        for (const subCondition of condition.conditions) {
-          dependencies.push(
-            ...extractFromCondition(tableName, subCondition, indexName)
-          );
-        }
-      }
-      break;
-    }
-  }
-  return dependencies;
-}
-function extractDependencies(operation) {
-  const dependencies = [];
-  for (const filter of operation.filters) {
-    dependencies.push(
-      ...extractFromCondition(operation.tableName, filter, operation.indexName)
-    );
+// ../server/src/log.ts
+var consoleLogger = globalThis.console;
+var SAFE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "ConditionalCheckFailedException",
+  "Error",
+  "GoneException",
+  "TransactionCanceledException"
+]);
+function sanitized(value) {
+  if (value instanceof Error) {
+    return {
+      errorName: SAFE_ERROR_NAMES.has(value.name) ? value.name : "Error"
+    };
   }
-  return dependencies;
+  if (value && typeof value === "object") return { valueType: "object" };
+  return value;
 }
-function createDependencyKey(dependency) {
-  return `${dependency.tableName}#${dependency.fieldName}#${dependency.fieldValue}`;
+function logger(method) {
+  return (...values) => consoleLogger[method](...values.map(sanitized));
 }
-function parseDependencyKey(key) {
-  const parts = key.split("#");
-  if (parts.length < 3) return null;
-  return {
-    tableName: parts[0],
-    fieldName: parts[1],
-    fieldValue: parts.slice(2).join("#")
-    // Handle values that contain #
-  };
+var debug = logger("debug");
+var info = logger("info");
+var error = logger("error");
+
+// ../server/src/handlers/reactive-handler.ts
+var MAX_TRANSACTION_DEPENDENCIES = 90;
+var MAX_QUERY_ENTRY_BYTES = 300 * 1024;
+var DYNAMODB_PARTITION_KEY_MAX_BYTES2 = 2048;
+var DYNAMODB_SORT_KEY_MAX_BYTES = 1024;
+var MAX_TABLE_PREFIX_LENGTH = 227;
+var DEFAULT_CONNECTION_LEASE_SECONDS = 3 * 60 * 60;
+function requestError(message, code) {
+  return new SafeRequestError(message, code);
 }
-function extractAffectedKeys(tableName, item) {
-  const keys = [];
-  for (const [fieldName, fieldValue] of Object.entries(item)) {
-    if (fieldValue !== null && fieldValue !== void 0) {
-      keys.push(`${tableName}#${fieldName}#${String(fieldValue)}`);
-      if (typeof fieldValue === "string") {
-        const maxPrefixLen = Math.min(fieldValue.length, 10);
-        for (let i = 1; i <= maxPrefixLen; i++) {
-          keys.push(
-            `${tableName}#${fieldName}#prefix:${fieldValue.substring(0, i)}`
-          );
-        }
-      }
-    }
+function validateTablePrefix(tablePrefix) {
+  if (typeof tablePrefix !== "string" || !/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(tablePrefix) || tablePrefix.length > MAX_TABLE_PREFIX_LENGTH) {
+    throw new Error(
+      "createReactiveHandler tablePrefix must be a nonempty concrete value of at most 227 letters, numbers, hyphens, or underscores, starting with a letter or number"
+    );
   }
-  return keys;
-}
-function operationToQueryMetadata(operation) {
-  const normalizeFilters = (filters) => {
-    return filters.map((f) => normalizeFilter(f));
-  };
-  const normalizeFilter = (filter) => {
-    if (filter.type === "comparison") {
-      const operatorMap = {
-        "=": "eq",
-        "<>": "ne",
-        ">": "gt",
-        ">=": "gte",
-        "<": "lt",
-        "<=": "lte"
-      };
-      return {
-        ...filter,
-        operator: operatorMap[filter.operator] ?? filter.operator
-      };
-    }
-    if (filter.type === "function") {
-      const operatorMap = {
-        begins_with: "beginsWith",
-        BETWEEN: "between"
-      };
-      return {
-        ...filter,
-        operator: operatorMap[filter.operator] ?? filter.operator
-      };
-    }
-    if (filter.conditions) {
-      const operatorMap = {
-        AND: "and",
-        OR: "or",
-        NOT: "not"
-      };
-      return {
-        ...filter,
-        operator: operatorMap[filter.operator] ?? filter.operator,
-        conditions: normalizeFilters(filter.conditions)
-      };
-    }
-    return filter;
-  };
-  return {
-    tableName: operation.tableName,
-    indexName: operation.indexName,
-    filterConditions: normalizeFilters(operation.filters),
-    sortField: operation.sortField,
-    sortOrder: operation.sortOrder,
-    limit: operation.limit
-  };
 }
-var DependencyTracker = class {
-  operations = [];
-  /**
-   * Track a query operation
-   */
-  track(operation) {
-    this.operations.push(operation);
-  }
-  /**
-   * Get all tracked operations
-   */
-  getOperations() {
-    return [...this.operations];
-  }
-  /**
-   * Extract all dependencies from tracked operations
-   */
-  extractAll() {
-    const dependencies = [];
-    for (const operation of this.operations) {
-      dependencies.push(...extractDependencies(operation));
-    }
-    return dependencies;
-  }
-  /**
-   * Get all dependency keys for the inverted index
-   */
-  getDependencyKeys() {
-    return this.extractAll().map(createDependencyKey);
-  }
-  /**
-   * Get query metadata for the first tracked operation.
-   * Used for storing subscription state.
-   */
-  getQueryMetadata() {
-    if (this.operations.length === 0) return null;
-    return operationToQueryMetadata(this.operations[0]);
-  }
-  /**
-   * Get the primary key field from the first operation
-   */
-  getPkField() {
-    if (this.operations.length === 0) return null;
-    return this.operations[0].pkField;
-  }
-  /**
-   * Get the sort key field from the first operation
-   */
-  getSkField() {
-    if (this.operations.length === 0) return void 0;
-    return this.operations[0].skField;
+function validateKeyString(name, value, maxBytes) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw requestError(`${name} must be a non-empty string`, 400);
   }
-  /**
-   * Clear tracked operations
-   */
-  clear() {
-    this.operations = [];
+  if (Buffer.byteLength(value, "utf8") > maxBytes) {
+    throw requestError(`${name} exceeds DynamoDB's UTF-8 key length limit`, 400);
   }
-};
-var { applyPatch, compare } = jsonpatch;
-function generatePatches(oldValue, newValue) {
-  const operations = compare(
-    oldValue,
-    newValue
-  );
-  return operations.map((op) => ({
-    op: op.op,
-    path: op.path,
-    value: "value" in op ? op.value : void 0,
-    from: "from" in op ? op.from : void 0
-  }));
 }
-function applyPatches(document, patches) {
-  const operations = patches.map((patch) => {
-    const op = {
-      op: patch.op,
-      path: patch.path
-    };
-    if ("value" in patch && patch.value !== void 0) {
-      op.value = patch.value;
-    }
-    if ("from" in patch && patch.from !== void 0) {
-      op.from = patch.from;
-    }
-    return op;
-  });
-  const result = applyPatch(
-    structuredClone(document),
-    operations,
-    true,
-    // Validate operations
-    false
-    // Don't mutate the original
+function validateRequest(request) {
+  validateKeyString(
+    "connectionId",
+    request.connectionId,
+    DYNAMODB_PARTITION_KEY_MAX_BYTES2
   );
-  return result.newDocument;
-}
-function hasChanges(oldValue, newValue) {
-  const patches = generatePatches(oldValue, newValue);
-  return patches.length > 0;
-}
-function optimizePatches(patches) {
-  const seen = /* @__PURE__ */ new Set();
-  const optimized = [];
-  for (let i = patches.length - 1; i >= 0; i--) {
-    const patch = patches[i];
-    if (!seen.has(patch.path)) {
-      seen.add(patch.path);
-      optimized.unshift(patch);
+  if (request.type === "subscribe" || request.type === "unsubscribe") {
+    validateKeyString(
+      "subscriptionId",
+      request.subscriptionId,
+      DYNAMODB_SORT_KEY_MAX_BYTES
+    );
+    validateKeyString(
+      "registrationId",
+      request.registrationId,
+      DYNAMODB_SORT_KEY_MAX_BYTES
+    );
+    if (Buffer.byteLength(
+      `${request.connectionId}#${request.subscriptionId}`,
+      "utf8"
+    ) > DYNAMODB_SORT_KEY_MAX_BYTES) {
+      throw requestError(
+        "connectionId and subscriptionId exceed DynamoDB dependency key limits",
+        400
+      );
+    }
+    if (!Number.isInteger(request.generation) || request.generation < 0) {
+      throw requestError("generation must be a non-negative integer", 400);
     }
   }
-  return optimized;
 }
-function batchPatches(patchSets) {
-  const allPatches = patchSets.flat();
-  return optimizePatches(allPatches);
+function assertEntrySize(entry) {
+  if (Buffer.byteLength(JSON.stringify(entry), "utf8") > MAX_QUERY_ENTRY_BYTES) {
+    throw new Error("Subscription result is too large to store safely");
+  }
 }
 function createReactiveHandler(config) {
-  const ttlSeconds = config.ttlSeconds ?? 3600;
-  const prefix = config.tablePrefix ? `${config.tablePrefix}-` : "";
+  validateTablePrefix(config.tablePrefix);
+  const ttlSeconds = config.ttlSeconds ?? DEFAULT_CONNECTION_LEASE_SECONDS;
+  const prefix = `${config.tablePrefix}-`;
   const connectionsTable = `${prefix}${SystemTableNames.connections}`;
   const dependenciesTable = `${prefix}${SystemTableNames.dependencies}`;
   const queriesTable = `${prefix}${SystemTableNames.queries}`;
-  const ddbClient = new DynamoDBClient({
-    region: config.dbConfig?.region ?? process.env.AWS_REGION
+  const ddbClient = config.dbConfig?.client ?? new DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION,
+    endpoint: config.dbConfig?.endpoint
   });
-  const docClient = DynamoDBDocumentClient.from(ddbClient, {
+  const docClient = config.dbConfig?.docClient ?? DynamoDBDocumentClient.from(ddbClient, {
     marshallOptions: { removeUndefinedValues: true }
   });
+  const dbConfig = {
+    ...config.dbConfig,
+    client: ddbClient,
+    docClient
+  };
+  async function authorize(requestInfo, context) {
+    const response = await docClient.send(
+      new GetCommand({
+        TableName: connectionsTable,
+        Key: { connectionId: requestInfo.connectionId },
+        ConsistentRead: true
+      })
+    );
+    const parsed = SystemSchemas.connections.safeParse(response.Item);
+    const now = Math.floor(Date.now() / 1e3);
+    if (!parsed.success || parsed.data.status !== "open" || parsed.data.ttl <= now) {
+      throw requestError("Connection is not open", 403);
+    }
+    if (!await config.authorizeConnection({
+      context,
+      connection: parsed.data,
+      requestInfo
+    })) {
+      throw requestError("Connection is not authorized", 403);
+    }
+    const refreshedTtl = now + ttlSeconds;
+    try {
+      await docClient.send(
+        new UpdateCommand({
+          TableName: connectionsTable,
+          Key: { connectionId: requestInfo.connectionId },
+          UpdateExpression: "SET #ttl = :ttl",
+          ConditionExpression: "#status = :open AND #ttl > :now AND connectedAt = :connectedAt",
+          ExpressionAttributeNames: { "#status": "status", "#ttl": "ttl" },
+          ExpressionAttributeValues: {
+            ":open": "open",
+            ":now": now,
+            ":ttl": refreshedTtl,
+            ":connectedAt": parsed.data.connectedAt
+          }
+        })
+      );
+    } catch (error2) {
+      if (error2 instanceof Error && error2.name === "ConditionalCheckFailedException") {
+        throw requestError("Connection is not open", 403);
+      }
+      throw error2;
+    }
+    return { ...parsed.data, ttl: refreshedTtl };
+  }
   async function handleRequest(request, headers) {
     try {
-      const connectionId = request.connectionId;
-      debug("[reactive-handler] handleRequest:", {
-        type: request.type,
-        connectionId,
-        path: "path" in request ? request.path : void 0
-      });
-      const ctx = await config.getContext({ connectionId, headers });
-      const dependencyTracker = new DependencyTracker();
-      const db = createDbContext(config.dbConfig ?? {}, dependencyTracker);
-      const fullCtx = { ...ctx, db };
-      switch (request.type) {
-        case "subscribe":
-          return await handleSubscribe(
-            connectionId,
-            request,
-            fullCtx,
-            dependencyTracker
-          );
-        case "unsubscribe":
-          return await handleUnsubscribe(connectionId, request);
-        case "call":
-          return await handleCall(request, fullCtx);
-        default:
-          return {
-            type: "error",
-            message: `Unknown request type: ${request.type}`
-          };
+      validateRequest(request);
+      const requestInfo = { connectionId: request.connectionId, headers };
+      const context = await config.getContext(requestInfo);
+      const connection = await authorize(requestInfo, context);
+      const tracker = new DependencyTracker();
+      const db = createDbContext(dbConfig, tracker);
+      const fullContext = { ...context, db };
+      if (request.type === "subscribe") {
+        return await handleSubscribe(request, fullContext, tracker, connection);
       }
-    } catch (error) {
+      if (request.type === "unsubscribe") {
+        return await handleUnsubscribe(request);
+      }
+      return await handleCall(request, fullContext);
+    } catch (error2) {
+      const safeError = isSafeRequestError(error2) ? error2 : null;
+      if (!safeError) error("[reactive-handler] Request failed", error2);
       return {
         type: "error",
-        message: error instanceof Error ? error.message : "Unknown error",
-        code: error.code,
-        subscriptionId: "subscriptionId" in request ? request.subscriptionId : void 0
+        message: safeError?.message ?? "Internal server error",
+        code: safeError?.statusCode ?? 500,
+        ..."subscriptionId" in request ? { subscriptionId: request.subscriptionId } : {}
       };
     }
   }
-  async function handleSubscribe(connectionId, request, ctx, dependencyTracker) {
-    const result = await config.router.execute(
+  async function activeSnapshot(request) {
+    const response = await docClient.send(
+      new GetCommand({
+        TableName: queriesTable,
+        Key: { pk: request.connectionId, sk: request.subscriptionId },
+        ConsistentRead: true
+      })
+    );
+    const query2 = SystemSchemas.queries.parse(response.Item);
+    if (query2.status !== "active" || query2.generation !== request.generation || query2.registrationId !== request.registrationId) {
+      throw new Error("Subscription registration was superseded");
+    }
+    return {
+      type: "snapshot",
+      subscriptionId: query2.subscriptionId,
+      generation: query2.generation,
+      version: query2.version,
+      data: query2.lastResult
+    };
+  }
+  async function handleSubscribe(request, context, tracker, connection) {
+    const procedure = config.router.getProcedure(request.path);
+    if (!procedure) throw requestError(`Procedure not found: ${request.path}`, 404);
+    if (procedure.type !== "query") {
+      throw requestError("Only query procedures can be subscribed to", 400);
+    }
+    const resolverResult = await config.router.execute(
       request.path,
-      ctx,
+      context,
       request.input
     );
-    const queryMetadata = dependencyTracker.getQueryMetadata();
-    const dependencyKeys = dependencyTracker.getDependencyKeys();
-    if (!queryMetadata) {
-      warn("[reactive-handler] No query metadata captured for subscription");
+    const operations = tracker.getOperations();
+    const capturedResult = tracker.getCapturedResult();
+    if (operations.length !== 1 || !capturedResult) {
+      throw requestError(
+        "A subscription must execute exactly one ctx.db query",
+        400
+      );
+    }
+    if (!Array.isArray(resolverResult) || resolverResult !== capturedResult.reference || !isDeepStrictEqual(resolverResult, capturedResult.snapshot)) {
+      throw requestError(
+        "A subscription resolver must return its ctx.db query result unchanged",
+        400
+      );
+    }
+    const queryMetadata = tracker.getQueryMetadata();
+    if (!queryMetadata) throw new Error("Query metadata was not captured");
+    const dependencies = tracker.extractAll();
+    const uniqueDependencies = new Map(
+      dependencies.map((dependency) => [createDependencyKey(dependency), dependency])
+    );
+    const dependencyKeys = [...uniqueDependencies.keys()];
+    if (uniqueDependencies.size > MAX_TRANSACTION_DEPENDENCIES) {
+      throw requestError("Query has too many reactive dependencies", 400);
     }
     const now = Date.now();
     const ttl = Math.floor(now / 1e3) + ttlSeconds;
-    const queryEntry = {
-      pk: connectionId,
+    const registering = {
+      pk: request.connectionId,
       sk: request.subscriptionId,
-      connectionId,
+      connectionId: request.connectionId,
       subscriptionId: request.subscriptionId,
-      queryMetadata: queryMetadata ?? {
-        tableName: "",
-        filterConditions: []
-      },
-      lastResult: result,
+      status: "registering",
+      generation: request.generation,
+      registrationId: request.registrationId,
+      queryMetadata,
+      lastResult: [],
       dependencies: dependencyKeys,
       version: 0,
       createdAt: now,
       updatedAt: now,
       ttl
     };
-    await docClient.send(
-      new PutCommand({
-        TableName: queriesTable,
-        Item: queryEntry
-      })
-    );
-    await Promise.all(
-      dependencyKeys.map(
-        (key) => docClient.send(
-          new PutCommand({
-            TableName: dependenciesTable,
-            Item: {
-              pk: key,
-              sk: `${connectionId}#${request.subscriptionId}`,
-              connectionId,
-              subscriptionId: request.subscriptionId,
-              ttl
-            }
-          })
-        )
+    let registrationEntry = registering;
+    assertEntrySize(registering);
+    const connectionCondition = {
+      TableName: connectionsTable,
+      Key: { connectionId: request.connectionId },
+      ConditionExpression: "#connectionStatus = :open AND #connectionTtl > :now AND connectedAt = :connectedAt",
+      ExpressionAttributeNames: {
+        "#connectionStatus": "status",
+        "#connectionTtl": "ttl"
+      },
+      ExpressionAttributeValues: {
+        ":open": "open",
+        ":now": Math.floor(Date.now() / 1e3),
+        ":connectedAt": connection.connectedAt
+      }
+    };
+    async function renewRegistration(query2) {
+      const dependencySk = `${request.connectionId}#${request.subscriptionId}`;
+      await docClient.send(
+        new TransactWriteCommand({
+          TransactItems: [
+            { ConditionCheck: connectionCondition },
+            {
+              Update: {
+                TableName: queriesTable,
+                Key: { pk: query2.pk, sk: query2.sk },
+                UpdateExpression: "SET #ttl = :ttl, updatedAt = :updatedAt",
+                ConditionExpression: "#status = :status AND #generation = :generation AND registrationId = :registrationId",
+                ExpressionAttributeNames: {
+                  "#status": "status",
+                  "#generation": "generation",
+                  "#ttl": "ttl"
+                },
+                ExpressionAttributeValues: {
+                  ":status": query2.status,
+                  ":generation": query2.generation,
+                  ":registrationId": query2.registrationId,
+                  ":ttl": ttl,
+                  ":updatedAt": Date.now()
+                }
+              }
+            },
+            ...[...new Set(query2.dependencies)].map((dependency) => ({
+              Update: {
+                TableName: dependenciesTable,
+                Key: { pk: dependency, sk: dependencySk },
+                UpdateExpression: "SET #ttl = :ttl",
+                ConditionExpression: "#generation = :generation AND registrationId = :registrationId",
+                ExpressionAttributeNames: {
+                  "#generation": "generation",
+                  "#ttl": "ttl"
+                },
+                ExpressionAttributeValues: {
+                  ":generation": query2.generation,
+                  ":registrationId": query2.registrationId,
+                  ":ttl": ttl
+                }
+              }
+            }))
+          ]
+        })
+      );
+    }
+    try {
+      await docClient.send(
+        new TransactWriteCommand({
+          TransactItems: [
+            { ConditionCheck: connectionCondition },
+            {
+              Put: {
+                TableName: queriesTable,
+                Item: registering,
+                ConditionExpression: "attribute_not_exists(pk) OR #generation < :generation",
+                ExpressionAttributeNames: {
+                  "#generation": "generation"
+                },
+                ExpressionAttributeValues: {
+                  ":generation": request.generation
+                }
+              }
+            },
+            ...[...uniqueDependencies].map(([key, dependency]) => {
+              const debugMetadata = parseDependencyKey(key) ?? dependency;
+              return {
+                Put: {
+                  TableName: dependenciesTable,
+                  Item: {
+                    pk: key,
+                    sk: `${request.connectionId}#${request.subscriptionId}`,
+                    connectionId: request.connectionId,
+                    subscriptionId: request.subscriptionId,
+                    tableName: debugMetadata.tableName,
+                    fieldName: debugMetadata.fieldName,
+                    fieldValue: debugMetadata.fieldValue,
+                    generation: request.generation,
+                    registrationId: request.registrationId,
+                    ttl
+                  }
+                }
+              };
+            })
+          ]
+        })
+      );
+    } catch (error2) {
+      const existing = await docClient.send(
+        new GetCommand({
+          TableName: queriesTable,
+          Key: { pk: request.connectionId, sk: request.subscriptionId },
+          ConsistentRead: true
+        })
+      );
+      const query2 = existing.Item;
+      if (!query2 || query2.generation !== request.generation || query2.registrationId !== request.registrationId || query2.status !== "registering" && query2.status !== "active") {
+        throw error2;
+      }
+      if (query2.status === "active") {
+        await renewRegistration(query2);
+        return activeSnapshot(request);
+      }
+      registrationEntry = query2;
+      try {
+        await renewRegistration(query2);
+      } catch (renewalError) {
+        const winner = await matchingActiveSnapshot(request, connection);
+        if (winner) return winner;
+        throw renewalError;
+      }
+    }
+    let baseline;
+    try {
+      baseline = await executeQueryMetadata(
+        ddbClient,
+        registrationEntry.queryMetadata
+      );
+      const active = {
+        ...registrationEntry,
+        status: "active",
+        lastResult: baseline
+      };
+      assertEntrySize(active);
+    } catch (error2) {
+      const winner = await matchingActiveSnapshot(request, connection);
+      if (winner) return winner;
+      await faultRegistration(request);
+      const winnerAfterFault = await matchingActiveSnapshot(request, connection);
+      if (winnerAfterFault) return winnerAfterFault;
+      throw error2;
+    }
+    try {
+      await docClient.send(
+        new UpdateCommand({
+          TableName: queriesTable,
+          Key: { pk: request.connectionId, sk: request.subscriptionId },
+          UpdateExpression: "SET #status = :active, lastResult = :lastResult, updatedAt = :updatedAt",
+          ConditionExpression: "#status = :registering AND #generation = :generation AND registrationId = :registrationId",
+          ExpressionAttributeNames: {
+            "#status": "status",
+            "#generation": "generation"
+          },
+          ExpressionAttributeValues: {
+            ":active": "active",
+            ":registering": "registering",
+            ":generation": request.generation,
+            ":registrationId": request.registrationId,
+            ":lastResult": baseline,
+            ":updatedAt": Date.now()
+          }
+        })
+      );
+    } catch (error2) {
+      const winner = await matchingActiveSnapshot(request, connection);
+      if (winner) return winner;
+      await faultRegistration(request);
+      const winnerAfterFault = await matchingActiveSnapshot(request, connection);
+      if (winnerAfterFault) return winnerAfterFault;
+      throw error2;
+    }
+    return activeSnapshot(request);
+  }
+  async function matchingActiveSnapshot(request, connection) {
+    const [queryResponse, connectionResponse] = await Promise.all([
+      docClient.send(
+        new GetCommand({
+          TableName: queriesTable,
+          Key: { pk: request.connectionId, sk: request.subscriptionId },
+          ConsistentRead: true
+        })
+      ),
+      docClient.send(
+        new GetCommand({
+          TableName: connectionsTable,
+          Key: { connectionId: request.connectionId },
+          ConsistentRead: true
+        })
       )
+    ]);
+    const query2 = queryResponse.Item;
+    const currentConnection = SystemSchemas.connections.safeParse(
+      connectionResponse.Item
     );
-    debug("[reactive-handler] Subscription created:", {
-      connectionId,
-      subscriptionId: request.subscriptionId,
-      tableName: queryMetadata?.tableName,
-      filterConditions: queryMetadata?.filterConditions,
-      dependencies: dependencyKeys,
-      isArrayResult: Array.isArray(result),
-      resultCount: Array.isArray(result) ? result.length : 1
-    });
+    if (query2?.status !== "active" || query2.generation !== request.generation || query2.registrationId !== request.registrationId || !currentConnection.success || currentConnection.data.status !== "open" || currentConnection.data.connectedAt !== connection.connectedAt) {
+      return null;
+    }
     return {
       type: "snapshot",
-      subscriptionId: request.subscriptionId,
-      data: result
+      subscriptionId: query2.subscriptionId,
+      generation: query2.generation,
+      version: query2.version,
+      data: query2.lastResult
     };
   }
-  async function handleUnsubscribe(connectionId, request) {
-    const subResponse = await docClient.send(
+  async function faultRegistration(request) {
+    await docClient.send(
+      new UpdateCommand({
+        TableName: queriesTable,
+        Key: { pk: request.connectionId, sk: request.subscriptionId },
+        UpdateExpression: "SET #status = :faulted, updatedAt = :updatedAt",
+        ConditionExpression: "#status = :registering AND #generation = :generation AND registrationId = :registrationId",
+        ExpressionAttributeNames: {
+          "#status": "status",
+          "#generation": "generation"
+        },
+        ExpressionAttributeValues: {
+          ":faulted": "faulted",
+          ":registering": "registering",
+          ":generation": request.generation,
+          ":registrationId": request.registrationId,
+          ":updatedAt": Date.now()
+        }
+      })
+    ).catch(() => void 0);
+  }
+  async function handleUnsubscribe(request) {
+    const response = await docClient.send(
       new GetCommand({
         TableName: queriesTable,
-        Key: { pk: connectionId, sk: request.subscriptionId }
+        Key: { pk: request.connectionId, sk: request.subscriptionId },
+        ConsistentRead: true
+      })
+    );
+    const query2 = response.Item;
+    if (!query2) return { type: "result", data: { success: true } };
+    if (query2.generation !== request.generation || query2.registrationId !== request.registrationId) {
+      throw requestError("Unsubscribe generation is stale", 409);
+    }
+    await docClient.send(
+      new UpdateCommand({
+        TableName: queriesTable,
+        Key: { pk: request.connectionId, sk: request.subscriptionId },
+        UpdateExpression: "SET #status = :cancelled, updatedAt = :updatedAt REMOVE pendingDelivery",
+        ConditionExpression: "#generation = :generation AND registrationId = :registrationId",
+        ExpressionAttributeNames: {
+          "#status": "status",
+          "#generation": "generation"
+        },
+        ExpressionAttributeValues: {
+          ":cancelled": "cancelled",
+          ":generation": request.generation,
+          ":registrationId": request.registrationId,
+          ":updatedAt": Date.now()
+        }
       })
     );
-    if (subResponse.Item) {
-      const queryEntry = subResponse.Item;
-      await Promise.all(
-        queryEntry.dependencies.map(
-          (key) => docClient.send(
+    await Promise.all(
+      query2.dependencies.map(async (key) => {
+        try {
+          await docClient.send(
             new DeleteCommand({
               TableName: dependenciesTable,
               Key: {
                 pk: key,
-                sk: `${connectionId}#${request.subscriptionId}`
-              }
+                sk: `${request.connectionId}#${request.subscriptionId}`
+              },
+              ConditionExpression: "#generation = :generation",
+              ExpressionAttributeNames: { "#generation": "generation" },
+              ExpressionAttributeValues: { ":generation": request.generation }
             })
-          )
-        )
-      );
-    }
-    await docClient.send(
-      new DeleteCommand({
-        TableName: queriesTable,
-        Key: { pk: connectionId, sk: request.subscriptionId }
+          );
+        } catch (error2) {
+          if (!(error2 instanceof Error) || error2.name !== "ConditionalCheckFailedException") {
+            throw error2;
+          }
+        }
       })
     );
-    debug("[reactive-handler] Subscription removed:", {
-      connectionId,
-      subscriptionId: request.subscriptionId
-    });
-    return {
-      type: "result",
-      data: { success: true }
-    };
+    return { type: "result", data: { success: true } };
   }
-  async function handleCall(request, ctx) {
-    const result = await config.router.execute(
-      request.path,
-      ctx,
-      request.input
-    );
+  async function handleCall(request, context) {
+    const procedure = config.router.getProcedure(request.path);
+    if (!procedure) throw requestError(`Procedure not found: ${request.path}`, 404);
+    if (procedure.type !== "mutation") {
+      throw requestError("Call requests require a mutation procedure", 400);
+    }
     return {
       type: "result",
-      data: result
+      data: await config.router.execute(request.path, context, request.input)
     };
   }
   async function registerConnection(connectionId, context) {
-    const now = Date.now();
-    const ttl = Math.floor(now / 1e3) + ttlSeconds;
-    const connectionEntry = {
+    validateKeyString(
+      "connectionId",
       connectionId,
-      context,
-      connectedAt: now,
-      ttl
-    };
+      DYNAMODB_PARTITION_KEY_MAX_BYTES2
+    );
+    const now = Date.now();
     await docClient.send(
       new PutCommand({
         TableName: connectionsTable,
-        Item: connectionEntry
+        Item: {
+          connectionId,
+          status: "open",
+          context,
+          connectedAt: now,
+          ttl: Math.floor(now / 1e3) + ttlSeconds
+        }
       })
     );
-    debug("[reactive-handler] Connection registered:", connectionEntry);
   }
   async function unregisterConnection(connectionId) {
-    const subsResponse = await docClient.send(
-      new QueryCommand({
-        TableName: queriesTable,
-        KeyConditionExpression: "pk = :pk",
-        ExpressionAttributeValues: { ":pk": connectionId }
-      })
-    );
-    const subscriptions = subsResponse.Items ?? [];
-    await Promise.all(
-      subscriptions.map(async (sub) => {
-        const deps = Array.isArray(sub.dependencies) ? sub.dependencies : [];
-        await Promise.all([
-          ...deps.map(
-            (depKey) => docClient.send(
-              new DeleteCommand({
-                TableName: dependenciesTable,
-                Key: { pk: depKey, sk: `${connectionId}#${sub.sk}` }
-              })
-            )
-          ),
-          docClient.send(
-            new DeleteCommand({
-              TableName: queriesTable,
-              Key: { pk: connectionId, sk: sub.sk }
-            })
-          )
-        ]);
-      })
+    validateKeyString(
+      "connectionId",
+      connectionId,
+      DYNAMODB_PARTITION_KEY_MAX_BYTES2
     );
     await docClient.send(
-      new DeleteCommand({
+      new UpdateCommand({
         TableName: connectionsTable,
-        Key: { connectionId }
+        Key: { connectionId },
+        UpdateExpression: "SET #status = :closed",
+        ConditionExpression: "attribute_exists(connectionId)",
+        ExpressionAttributeNames: { "#status": "status" },
+        ExpressionAttributeValues: { ":closed": "closed" }
       })
     );
-    debug(
-      "[reactive-handler] Connection unregistered:",
-      connectionId,
-      `(${subscriptions.length} subscriptions removed)`
-    );
+    let lastKey;
+    do {
+      const response = await docClient.send(
+        new QueryCommand({
+          TableName: queriesTable,
+          KeyConditionExpression: "pk = :pk",
+          ExpressionAttributeValues: { ":pk": connectionId },
+          ConsistentRead: true,
+          ExclusiveStartKey: lastKey
+        })
+      );
+      for (const item of response.Items ?? []) {
+        const query2 = item;
+        await handleUnsubscribe({
+          type: "unsubscribe",
+          connectionId,
+          subscriptionId: query2.subscriptionId,
+          generation: query2.generation,
+          registrationId: query2.registrationId
+        });
+      }
+      lastKey = response.LastEvaluatedKey;
+    } while (lastKey);
+    debug("[reactive-handler] Connection unregistered");
   }
   async function query(path, input, headers) {
-    const ctx = await config.getContext({ connectionId: "query", headers });
-    const dependencyTracker = new DependencyTracker();
-    const db = createDbContext(config.dbConfig ?? {}, dependencyTracker);
-    const fullCtx = { ...ctx, db };
-    return config.router.execute(path, fullCtx, input);
+    const procedure = config.router.getProcedure(path);
+    if (!procedure) throw requestError(`Procedure not found: ${path}`, 404);
+    if (procedure.type !== "query") {
+      throw requestError("One-time query requests require a query procedure", 400);
+    }
+    const context = await config.getContext({ connectionId: "query", headers });
+    const db = createDbContext(dbConfig);
+    return config.router.execute(
+      path,
+      { ...context, db },
+      input
+    );
   }
   function createCaller() {
     function buildProxy(path = []) {
-      return new Proxy(() => {
-      }, {
-        get(_target, prop) {
-          return buildProxy([...path, prop]);
+      return new Proxy(() => void 0, {
+        get(_target, property) {
+          return buildProxy([...path, property]);
         },
         apply(_target, _thisArg, args) {
-          const procedurePath = path.join(".");
-          return query(procedurePath, args[0]);
+          return query(path.join("."), args[0]);
         }
       });
     }
@@ -997,74 +1658,37 @@ function createReactiveHandler(config) {
     createCaller
   };
 }
-function extractTableName(record) {
-  const arn = record.eventSourceARN;
-  if (!arn) return null;
-  const match = arn.match(/table\/([^/]+)/);
-  return match ? match[1] : null;
-}
-function buildWhereClause(conditions) {
-  if (conditions.length === 0) return "";
-  const clauses = conditions.map((c) => buildConditionClause(c)).filter(Boolean);
-  if (clauses.length === 0) return "";
-  return `WHERE ${clauses.join(" AND ")}`;
-}
-function buildConditionClause(condition) {
-  const { type, operator, field, value, value2, conditions } = condition;
-  if (type === "comparison" && field) {
-    const escapedValue = escapeValue(value);
-    switch (operator) {
-      case "eq":
-        return `"${field}" = ${escapedValue}`;
-      case "ne":
-        return `"${field}" <> ${escapedValue}`;
-      case "gt":
-        return `"${field}" > ${escapedValue}`;
-      case "gte":
-        return `"${field}" >= ${escapedValue}`;
-      case "lt":
-        return `"${field}" < ${escapedValue}`;
-      case "lte":
-        return `"${field}" <= ${escapedValue}`;
-      case "between":
-        return `"${field}" BETWEEN ${escapedValue} AND ${escapeValue(value2)}`;
-      default:
-        return "";
-    }
-  }
-  if (type === "function" && field) {
-    const escapedValue = escapeValue(value);
-    switch (operator) {
-      case "beginsWith":
-        return `begins_with("${field}", ${escapedValue})`;
-      case "contains":
-        return `contains("${field}", ${escapedValue})`;
-      default:
-        return "";
-    }
-  }
-  if (type === "logical" && conditions) {
-    const subclauses = conditions.map((c) => buildConditionClause(c)).filter(Boolean);
-    if (subclauses.length === 0) return "";
-    switch (operator) {
-      case "and":
-        return `(${subclauses.join(" AND ")})`;
-      case "or":
-        return `(${subclauses.join(" OR ")})`;
-      case "not":
-        return subclauses.length > 0 ? `NOT (${subclauses[0]})` : "";
-      default:
-        return "";
-    }
+var { compare } = jsonpatch;
+function generatePatches(oldValue, newValue) {
+  const operations = compare(
+    oldValue,
+    newValue
+  );
+  return operations.map((op) => ({
+    op: op.op,
+    path: op.path,
+    ..."value" in op ? { value: op.value } : {},
+    ..."from" in op ? { from: op.from } : {}
+  }));
+}
+
+// ../server/src/handlers/stream-utils.ts
+var MAX_PATCH_MESSAGE_BYTES = 30 * 1024;
+var MAX_QUERY_ENTRY_BYTES2 = 300 * 1024;
+var MAX_PROCESS_ATTEMPTS = 4;
+var REGISTRATION_WINDOW_MS = 60 * 1e3;
+var RetryableSubscriptionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RetryableSubscriptionError";
   }
-  return "";
+};
+function extractTableName(record) {
+  const match = record.eventSourceARN?.match(/table\/([^/]+)/);
+  return match?.[1] ?? null;
 }
-function escapeValue(value) {
-  if (value === null || value === void 0) return "NULL";
-  if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-  return `'${String(value).replace(/'/g, "''")}'`;
+function isConditionalFailure(error2) {
+  return error2 instanceof Error && error2.name === "ConditionalCheckFailedException";
 }
 function createStreamUtils(config) {
   const {
@@ -1074,435 +1698,624 @@ function createStreamUtils(config) {
     dependenciesTable,
     queriesTable
   } = config;
-  const getApiClient = /* @__PURE__ */ (() => {
-    let client;
-    return () => {
-      client ??= new ApiGatewayManagementApiClient({
-        endpoint: config.apiGatewayEndpoint
-      });
-      return client;
-    };
-  })();
+  let apiClient = config.apiClient;
+  function getApiClient() {
+    apiClient ??= new ApiGatewayManagementApiClient({
+      endpoint: config.apiGatewayEndpoint
+    });
+    return apiClient;
+  }
   async function findAffectedSubscriptions(dependencyKey) {
-    try {
+    const subscriptions = [];
+    let lastKey;
+    do {
       const response = await docClient.send(
         new QueryCommand({
           TableName: dependenciesTable,
           KeyConditionExpression: "pk = :pk",
-          ExpressionAttributeValues: { ":pk": dependencyKey }
+          ExpressionAttributeValues: { ":pk": dependencyKey },
+          ConsistentRead: true,
+          ExclusiveStartKey: lastKey
         })
       );
-      return (response.Items ?? []).map((item) => ({
-        connectionId: item.connectionId,
-        subscriptionId: item.subscriptionId
-      }));
-    } catch (error$1) {
-      error("Error finding affected subscriptions:", error$1);
-      return [];
-    }
+      subscriptions.push(
+        ...(response.Items ?? []).map((item) => ({
+          connectionId: item.connectionId,
+          subscriptionId: item.subscriptionId
+        }))
+      );
+      lastKey = response.LastEvaluatedKey;
+    } while (lastKey);
+    return subscriptions;
   }
   async function executeQueryFromMetadata(metadata) {
-    const { tableName, filterConditions, sortOrder, limit } = metadata;
-    const whereClause = buildWhereClause(filterConditions);
-    const orderClause = sortOrder === "desc" ? "ORDER BY SK DESC" : "";
-    const limitClause = limit ? `LIMIT ${limit}` : "";
-    const statement = `SELECT * FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause}`.trim();
-    try {
-      const result = await ddbClient.send(
-        new ExecuteStatementCommand({ Statement: statement })
-      );
-      return (result.Items ?? []).map(
-        (item) => unmarshall(item)
-      );
-    } catch (error$1) {
-      error("Error executing query from metadata:", error$1);
-      error("Statement:", statement);
-      return [];
-    }
+    return executeQueryMetadata(ddbClient, metadata);
   }
-  async function sendPatch(connectionId, subscriptionId, patches) {
-    const message = JSON.stringify({
-      type: "patch",
-      subscriptionId,
-      patches
-    });
+  function deliveryMessage(query, delivery) {
+    return {
+      type: delivery.type,
+      subscriptionId: query.subscriptionId,
+      generation: delivery.generation,
+      fromVersion: delivery.fromVersion,
+      toVersion: delivery.toVersion,
+      messageId: delivery.messageId,
+      ...delivery.type === "patch" ? { patches: delivery.patches } : {}
+    };
+  }
+  async function sendDelivery(query, delivery) {
+    await getApiClient().send(
+      new PostToConnectionCommand({
+        ConnectionId: query.connectionId,
+        Data: Buffer.from(JSON.stringify(deliveryMessage(query, delivery)))
+      })
+    );
+  }
+  async function clearDelivery(query, delivery) {
     try {
-      await getApiClient().send(
-        new PostToConnectionCommand({
-          ConnectionId: connectionId,
-          Data: Buffer.from(message)
+      await docClient.send(
+        new UpdateCommand({
+          TableName: queriesTable,
+          Key: { pk: query.pk, sk: query.sk },
+          UpdateExpression: "REMOVE pendingDelivery",
+          ConditionExpression: "#status = :status AND #generation = :generation AND registrationId = :registrationId AND pendingDelivery.messageId = :messageId",
+          ExpressionAttributeNames: {
+            "#status": "status",
+            "#generation": "generation"
+          },
+          ExpressionAttributeValues: {
+            ":status": query.status,
+            ":generation": query.generation,
+            ":registrationId": query.registrationId,
+            ":messageId": delivery.messageId
+          }
         })
       );
-    } catch (error$1) {
-      if (error$1 instanceof GoneException) {
-        throw error$1;
-      }
-      error(`Error sending patch to ${connectionId}:`, error$1);
+    } catch (error2) {
+      if (!isConditionalFailure(error2)) throw error2;
     }
   }
+  async function cleanupSubscriptionDependencies(query) {
+    await Promise.all(
+      query.dependencies.map(async (dependency) => {
+        try {
+          await docClient.send(
+            new DeleteCommand({
+              TableName: dependenciesTable,
+              Key: {
+                pk: dependency,
+                sk: `${query.connectionId}#${query.subscriptionId}`
+              },
+              ConditionExpression: "#generation = :generation AND registrationId = :registrationId",
+              ExpressionAttributeNames: { "#generation": "generation" },
+              ExpressionAttributeValues: {
+                ":generation": query.generation,
+                ":registrationId": query.registrationId
+              }
+            })
+          );
+        } catch (error2) {
+          if (!isConditionalFailure(error2)) throw error2;
+        }
+      })
+    );
+  }
   async function processSubscription(connectionId, subscriptionId) {
     try {
-      const response = await docClient.send(
-        new GetCommand({
-          TableName: queriesTable,
-          Key: { pk: connectionId, sk: subscriptionId }
-        })
-      );
-      const queryState = response.Item;
-      if (!queryState) {
-        warn(`Subscription not found: ${connectionId}/${subscriptionId}`);
-        return;
-      }
-      const rawNewResult = await executeQueryFromMetadata(
-        queryState.queryMetadata
-      );
-      const isSingleItemResult = !Array.isArray(queryState.lastResult);
-      const newResult = isSingleItemResult ? rawNewResult[0] ?? null : rawNewResult;
-      if (!hasChanges(queryState.lastResult, newResult)) {
-        info(
-          `[stream] No changes for ${subscriptionId} (version ${queryState.version ?? 0})`
-        );
-        return;
-      }
-      const patches = generatePatches(queryState.lastResult, newResult);
-      info(
-        `[stream] ${subscriptionId}: ${patches.length} patch ops, version ${queryState.version ?? 0} \u2192 ${(queryState.version ?? 0) + 1}`,
-        {
-          ops: patches.map((p) => `${p.op} ${p.path}`).join(", ")
-        }
-      );
-      const currentVersion = queryState.version ?? 0;
-      try {
-        await docClient.send(
-          new PutCommand({
+      for (let attempt = 0; attempt < MAX_PROCESS_ATTEMPTS; attempt++) {
+        const response = await docClient.send(
+          new GetCommand({
             TableName: queriesTable,
-            Item: {
-              ...queryState,
-              lastResult: newResult,
-              version: currentVersion + 1,
-              updatedAt: Date.now()
-            },
-            ConditionExpression: "attribute_not_exists(version) OR version = :v",
-            ExpressionAttributeValues: { ":v": currentVersion }
+            Key: { pk: connectionId, sk: subscriptionId },
+            ConsistentRead: true
           })
         );
-      } catch (error) {
-        if (error instanceof Error && error.name === "ConditionalCheckFailedException") {
-          info(
-            `[stream] Version conflict for ${subscriptionId} at version ${currentVersion}, skipping (another invocation won)`
-          );
+        const query = response.Item;
+        if (!query || query.status === "cancelled") {
+          return;
+        }
+        if (query.pendingDelivery) {
+          await sendDelivery(query, query.pendingDelivery);
+          await clearDelivery(query, query.pendingDelivery);
+          if (query.status === "faulted") {
+            await cleanupSubscriptionDependencies(query);
+            return;
+          }
+          continue;
+        }
+        if (query.status === "faulted") {
+          await cleanupSubscriptionDependencies(query);
           return;
         }
-        throw error;
+        if (query.status === "registering") {
+          if (query.createdAt <= Date.now() - REGISTRATION_WINDOW_MS) {
+            try {
+              await docClient.send(
+                new UpdateCommand({
+                  TableName: queriesTable,
+                  Key: { pk: query.pk, sk: query.sk },
+                  UpdateExpression: "SET #status = :faulted, updatedAt = :updatedAt",
+                  ConditionExpression: "#status = :registering AND #generation = :generation AND registrationId = :registrationId AND createdAt = :createdAt AND createdAt <= :registrationCutoff",
+                  ExpressionAttributeNames: {
+                    "#status": "status",
+                    "#generation": "generation"
+                  },
+                  ExpressionAttributeValues: {
+                    ":faulted": "faulted",
+                    ":registering": "registering",
+                    ":generation": query.generation,
+                    ":registrationId": query.registrationId,
+                    ":createdAt": query.createdAt,
+                    ":registrationCutoff": Date.now() - REGISTRATION_WINDOW_MS,
+                    ":updatedAt": Date.now()
+                  }
+                })
+              );
+              return;
+            } catch (error2) {
+              if (isConditionalFailure(error2)) continue;
+              throw error2;
+            }
+          }
+          throw new RetryableSubscriptionError(
+            `Subscription ${connectionId}/${subscriptionId} is still registering`
+          );
+        }
+        const newResult = await executeQueryFromMetadata(query.queryMetadata);
+        const patches = generatePatches(query.lastResult, newResult);
+        if (patches.length === 0) return;
+        const fromVersion = query.version;
+        const toVersion = fromVersion + 1;
+        const patchDelivery = {
+          type: "patch",
+          generation: query.generation,
+          fromVersion,
+          toVersion,
+          messageId: randomUUID(),
+          patches
+        };
+        const pendingDelivery = Buffer.byteLength(
+          JSON.stringify(deliveryMessage(query, patchDelivery)),
+          "utf8"
+        ) > MAX_PATCH_MESSAGE_BYTES ? {
+          type: "resync",
+          generation: query.generation,
+          fromVersion,
+          toVersion,
+          messageId: patchDelivery.messageId
+        } : patchDelivery;
+        const persisted = {
+          ...query,
+          lastResult: newResult,
+          version: toVersion,
+          pendingDelivery
+        };
+        if (Buffer.byteLength(JSON.stringify(persisted), "utf8") > MAX_QUERY_ENTRY_BYTES2) {
+          const faultDelivery = {
+            type: "resync",
+            generation: query.generation,
+            fromVersion,
+            toVersion,
+            messageId: pendingDelivery.messageId
+          };
+          try {
+            await docClient.send(
+              new UpdateCommand({
+                TableName: queriesTable,
+                Key: { pk: query.pk, sk: query.sk },
+                UpdateExpression: "SET #status = :faulted, pendingDelivery = :pendingDelivery, updatedAt = :updatedAt",
+                ConditionExpression: "#status = :active AND #generation = :generation AND registrationId = :registrationId AND #version = :fromVersion AND attribute_not_exists(pendingDelivery)",
+                ExpressionAttributeNames: {
+                  "#status": "status",
+                  "#generation": "generation",
+                  "#version": "version"
+                },
+                ExpressionAttributeValues: {
+                  ":active": "active",
+                  ":faulted": "faulted",
+                  ":generation": query.generation,
+                  ":registrationId": query.registrationId,
+                  ":fromVersion": fromVersion,
+                  ":pendingDelivery": faultDelivery,
+                  ":updatedAt": Date.now()
+                }
+              })
+            );
+          } catch (error2) {
+            if (isConditionalFailure(error2)) {
+              throw new RetryableSubscriptionError(
+                `Subscription ${connectionId}/${subscriptionId} changed concurrently`
+              );
+            }
+            throw error2;
+          }
+          continue;
+        }
+        try {
+          await docClient.send(
+            new UpdateCommand({
+              TableName: queriesTable,
+              Key: { pk: query.pk, sk: query.sk },
+              UpdateExpression: "SET lastResult = :lastResult, #version = :toVersion, pendingDelivery = :pendingDelivery, updatedAt = :updatedAt",
+              ConditionExpression: "#status = :active AND #generation = :generation AND registrationId = :registrationId AND #version = :fromVersion AND attribute_not_exists(pendingDelivery)",
+              ExpressionAttributeNames: {
+                "#status": "status",
+                "#generation": "generation",
+                "#version": "version"
+              },
+              ExpressionAttributeValues: {
+                ":active": "active",
+                ":generation": query.generation,
+                ":registrationId": query.registrationId,
+                ":fromVersion": fromVersion,
+                ":toVersion": toVersion,
+                ":lastResult": newResult,
+                ":pendingDelivery": pendingDelivery,
+                ":updatedAt": Date.now()
+              }
+            })
+          );
+        } catch (error2) {
+          if (isConditionalFailure(error2)) {
+            throw new RetryableSubscriptionError(
+              `Subscription ${connectionId}/${subscriptionId} changed concurrently`
+            );
+          }
+          throw error2;
+        }
+        await sendDelivery(query, pendingDelivery);
+        await clearDelivery(query, pendingDelivery);
+        info("[stream] Delivery completed");
+        return;
       }
-      await sendPatch(connectionId, subscriptionId, patches);
-    } catch (error$1) {
-      if (error$1 instanceof GoneException) {
+      throw new RetryableSubscriptionError(
+        `Subscription ${connectionId}/${subscriptionId} delivery did not settle`
+      );
+    } catch (error2) {
+      if (error2 instanceof GoneException) {
         await cleanupConnection(connectionId);
-      } else {
-        error(
-          `Error processing subscription ${connectionId}/${subscriptionId}:`,
-          error$1
-        );
+        return;
       }
+      throw error2;
     }
   }
   async function cleanupConnection(connectionId) {
-    info("Cleaning up disconnected connection:", connectionId);
     try {
-      const subsResponse = await docClient.send(
+      await docClient.send(
+        new UpdateCommand({
+          TableName: connectionsTable,
+          Key: { connectionId },
+          UpdateExpression: "SET #status = :closed",
+          ConditionExpression: "attribute_exists(connectionId)",
+          ExpressionAttributeNames: { "#status": "status" },
+          ExpressionAttributeValues: { ":closed": "closed" }
+        })
+      );
+    } catch (error2) {
+      if (!isConditionalFailure(error2)) throw error2;
+    }
+    let lastKey;
+    do {
+      const response = await docClient.send(
         new QueryCommand({
           TableName: queriesTable,
           KeyConditionExpression: "pk = :pk",
-          ExpressionAttributeValues: { ":pk": connectionId }
+          ExpressionAttributeValues: { ":pk": connectionId },
+          ConsistentRead: true,
+          ExclusiveStartKey: lastKey
         })
       );
-      const subscriptions = subsResponse.Items ?? [];
-      await Promise.all(
-        subscriptions.map(async (sub) => {
-          const deps = Array.isArray(sub.dependencies) ? sub.dependencies : [];
-          await Promise.all([
-            ...deps.map(
-              (depKey) => docClient.send(
-                new DeleteCommand({
-                  TableName: dependenciesTable,
-                  Key: { pk: depKey, sk: `${connectionId}#${sub.sk}` }
-                })
-              )
-            ),
-            docClient.send(
-              new DeleteCommand({
+      for (const item of response.Items ?? []) {
+        const query = item;
+        if (query.status !== "cancelled") {
+          try {
+            await docClient.send(
+              new UpdateCommand({
                 TableName: queriesTable,
-                Key: { pk: connectionId, sk: sub.sk }
+                Key: { pk: query.pk, sk: query.sk },
+                UpdateExpression: "SET #status = :cancelled, updatedAt = :updatedAt REMOVE pendingDelivery",
+                ConditionExpression: "#generation = :generation AND registrationId = :registrationId",
+                ExpressionAttributeNames: {
+                  "#status": "status",
+                  "#generation": "generation"
+                },
+                ExpressionAttributeValues: {
+                  ":cancelled": "cancelled",
+                  ":generation": query.generation,
+                  ":registrationId": query.registrationId,
+                  ":updatedAt": Date.now()
+                }
               })
-            )
-          ]);
-        })
-      );
-      await docClient.send(
-        new DeleteCommand({
-          TableName: connectionsTable,
-          Key: { connectionId }
-        })
-      );
-      info(
-        "Connection cleaned up:",
-        connectionId,
-        `(${subscriptions.length} subscriptions removed)`
-      );
-    } catch (error$1) {
-      error("Error cleaning up connection:", error$1);
-    }
+            );
+          } catch (error2) {
+            if (!isConditionalFailure(error2)) throw error2;
+            continue;
+          }
+        }
+        await cleanupSubscriptionDependencies(query);
+      }
+      lastKey = response.LastEvaluatedKey;
+    } while (lastKey);
   }
   return {
     findAffectedSubscriptions,
     executeQueryFromMetadata,
-    sendPatch,
+    sendDelivery,
     processSubscription,
     cleanupConnection
   };
 }
 
 // ../server/src/handlers/stream-handler.ts
-function createStreamHandler(config) {
-  const connectionsTable = config.connectionsTableName ?? SystemTableNames.connections;
-  const dependenciesTable = config.dependenciesTableName ?? SystemTableNames.dependencies;
-  const queriesTable = config.queriesTableName ?? SystemTableNames.queries;
-  const ddbClient = new DynamoDBClient({
-    region: config.dbConfig?.region ?? process.env.AWS_REGION
-  });
-  const docClient = DynamoDBDocumentClient.from(ddbClient);
-  const utils = createStreamUtils({
-    ddbClient,
-    docClient,
-    apiGatewayEndpoint: config.apiGatewayEndpoint,
-    connectionsTable,
-    dependenciesTable,
-    queriesTable
-  });
-  async function handler(event) {
-    info(
-      `[stream] Processing ${event.Records.length} records from DynamoDB stream`
-    );
-    const affectedSubscriptions = /* @__PURE__ */ new Map();
-    const affectedKeys = /* @__PURE__ */ new Set();
-    for (const record of event.Records) {
-      if (!record.dynamodb) continue;
-      const tableName = extractTableName(record);
-      if (!tableName) continue;
-      const newImage = record.dynamodb.NewImage ? unmarshall(record.dynamodb.NewImage) : null;
-      const oldImage = record.dynamodb.OldImage ? unmarshall(record.dynamodb.OldImage) : null;
-      if (newImage) {
-        for (const key of extractAffectedKeys(tableName, newImage)) {
-          affectedKeys.add(key);
-        }
-      }
-      if (oldImage) {
-        for (const key of extractAffectedKeys(tableName, oldImage)) {
-          affectedKeys.add(key);
-        }
-      }
-    }
-    debug("[stream] Affected keys:", affectedKeys.size);
-    const lookupResults = await Promise.all(
-      [...affectedKeys].map((key) => utils.findAffectedSubscriptions(key))
-    );
-    for (const subscriptions of lookupResults) {
-      for (const sub of subscriptions) {
-        if (!affectedSubscriptions.has(sub.connectionId)) {
-          affectedSubscriptions.set(sub.connectionId, /* @__PURE__ */ new Set());
-        }
-        affectedSubscriptions.get(sub.connectionId).add(sub.subscriptionId);
+var MAX_FANOUT_CONCURRENCY = 10;
+var DYNAMODB_PARTITION_KEY_MAX_BYTES3 = 2048;
+function assertConnectionId(connectionId) {
+  if (typeof connectionId !== "string" || connectionId.length === 0 || Buffer.byteLength(connectionId, "utf8") > DYNAMODB_PARTITION_KEY_MAX_BYTES3) {
+    throw new Error("connectionId is not a valid DynamoDB partition key");
+  }
+}
+async function mapWithConcurrency(values, concurrency, mapper) {
+  const results = new Array(values.length);
+  let nextIndex = 0;
+  const workers = Array.from(
+    { length: Math.min(concurrency, values.length) },
+    async () => {
+      while (nextIndex < values.length) {
+        const index = nextIndex++;
+        results[index] = await mapper(values[index], index);
       }
     }
-    let totalSubs = 0;
-    for (const [, subs] of affectedSubscriptions) {
-      totalSubs += subs.size;
+  );
+  await Promise.all(workers);
+  return results;
+}
+async function processRecord(record, utils) {
+  const tableName = extractTableName(record);
+  if (!tableName || !record.dynamodb) {
+    throw new Error("Malformed DynamoDB stream record");
+  }
+  const affectedKeys = new Set(extractAffectedKeys(tableName, {}));
+  for (const image of [record.dynamodb.NewImage, record.dynamodb.OldImage]) {
+    if (!image) continue;
+    const item = unmarshall(image);
+    for (const key of extractAffectedKeys(tableName, item)) affectedKeys.add(key);
+  }
+  const subscriptions = /* @__PURE__ */ new Map();
+  const lookupResults = await mapWithConcurrency(
+    [...affectedKeys],
+    MAX_FANOUT_CONCURRENCY,
+    (key) => utils.findAffectedSubscriptions(key)
+  );
+  for (const result of lookupResults) {
+    for (const subscription of result) {
+      subscriptions.set(
+        `${subscription.connectionId}\0${subscription.subscriptionId}`,
+        subscription
+      );
     }
-    info(
-      `[stream] Found ${affectedSubscriptions.size} affected connections, ${totalSubs} subscriptions`
-    );
-    const sendPromises = [];
-    for (const [connectionId, subscriptionIds] of affectedSubscriptions) {
-      for (const subscriptionId of subscriptionIds) {
-        sendPromises.push(
-          utils.processSubscription(connectionId, subscriptionId)
-        );
+  }
+  await mapWithConcurrency(
+    [...subscriptions.values()],
+    MAX_FANOUT_CONCURRENCY,
+    ({ connectionId, subscriptionId }) => utils.processSubscription(connectionId, subscriptionId)
+  );
+}
+async function processStreamEvent(event, utils) {
+  const results = await mapWithConcurrency(
+    event.Records,
+    MAX_FANOUT_CONCURRENCY,
+    async (record) => {
+      try {
+        await processRecord(record, utils);
+        return null;
+      } catch (error2) {
+        error("[stream] Record failed:", error2);
+        const itemIdentifier = record.dynamodb?.SequenceNumber;
+        if (!itemIdentifier) {
+          throw new Error(
+            "Failed DynamoDB stream record has no sequence number",
+            { cause: error2 }
+          );
+        }
+        return {
+          itemIdentifier
+        };
       }
     }
-    await Promise.allSettled(sendPromises);
-    info("[stream] Processing complete");
-  }
-  return { handler };
+  );
+  return {
+    batchItemFailures: results.filter(
+      (failure) => failure !== null
+    )
+  };
 }
-function createConnectHandler(config) {
-  const connectionsTable = config.connectionsTableName ?? SystemTableNames.connections;
-  const ddbClient = new DynamoDBClient({
-    region: config.dbConfig?.region ?? process.env.AWS_REGION
+function clients(config) {
+  const ddbClient = config.dbConfig?.client ?? new DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION,
+    endpoint: config.dbConfig?.endpoint
+  });
+  const docClient = config.dbConfig?.docClient ?? DynamoDBDocumentClient.from(ddbClient, {
+    marshallOptions: { removeUndefinedValues: true }
   });
-  const docClient = DynamoDBDocumentClient.from(ddbClient);
+  return { ddbClient, docClient };
+}
+function createConnectHandler(config) {
+  const connectionsTable = config.connectionsTableName;
+  const { docClient } = clients(config);
   return async function handler(event) {
     const connectionId = event.requestContext.connectionId;
     const now = Date.now();
-    const ttl = Math.floor(now / 1e3) + 3600;
     try {
+      assertConnectionId(connectionId);
+      const authorizerContext = jsonSafeRecord(event.requestContext.authorizer);
+      const requestIdentity = jsonSafeRecord(event.requestContext.identity);
       const connectionEntry = {
         connectionId,
-        context: event.requestContext.authorizer,
+        status: "open",
+        ...authorizerContext ? { authorizerContext } : {},
+        ...requestIdentity ? { requestIdentity } : {},
         connectedAt: now,
-        ttl
+        ttl: Math.floor(now / 1e3) + DEFAULT_CONNECTION_LEASE_SECONDS
       };
       await docClient.send(
-        new PutCommand({
-          TableName: connectionsTable,
-          Item: connectionEntry
-        })
+        new PutCommand({ TableName: connectionsTable, Item: connectionEntry })
       );
-      debug("[stream] Connection established:", connectionId);
+      debug("[stream] Connection established");
       return { statusCode: 200 };
-    } catch (error$1) {
-      error("Error creating connection:", error$1);
+    } catch (error2) {
+      error("Error creating connection:", error2);
       return { statusCode: 500 };
     }
   };
 }
+function jsonSafeRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  try {
+    const encoded = JSON.stringify(value, (_key, item) => {
+      if (typeof item === "bigint") return item.toString();
+      if (typeof item === "function" || typeof item === "symbol" || item === void 0) {
+        return void 0;
+      }
+      return item;
+    });
+    if (!encoded) return void 0;
+    return JSON.parse(encoded);
+  } catch {
+    return void 0;
+  }
+}
 function createDisconnectHandler(config) {
-  const connectionsTable = config.connectionsTableName ?? SystemTableNames.connections;
-  const dependenciesTable = config.dependenciesTableName ?? SystemTableNames.dependencies;
-  const queriesTable = config.queriesTableName ?? SystemTableNames.queries;
-  const ddbClient = new DynamoDBClient({
-    region: config.dbConfig?.region ?? process.env.AWS_REGION
-  });
-  const docClient = DynamoDBDocumentClient.from(ddbClient);
+  const connectionsTable = config.connectionsTableName;
+  const dependenciesTable = config.dependenciesTableName;
+  const queriesTable = config.queriesTableName;
+  const { ddbClient, docClient } = clients(config);
   const utils = createStreamUtils({
     ddbClient,
     docClient,
+    apiClient: config.apiClient,
     apiGatewayEndpoint: config.apiGatewayEndpoint,
     connectionsTable,
     dependenciesTable,
     queriesTable
   });
   return async function handler(event) {
-    const connectionId = event.requestContext.connectionId;
     try {
+      const connectionId = event.requestContext.connectionId;
+      assertConnectionId(connectionId);
       await utils.cleanupConnection(connectionId);
       return { statusCode: 200 };
-    } catch (error$1) {
-      error("Error removing connection:", error$1);
+    } catch (error2) {
+      error("Error removing connection:", error2);
       return { statusCode: 500 };
     }
   };
 }
-function createLambdaHandlers() {
-  const connectionsTable = process.env.CONNECTIONS_TABLE ?? SystemTableNames.connections;
-  const dependenciesTable = process.env.DEPENDENCIES_TABLE ?? SystemTableNames.dependencies;
-  const queriesTable = process.env.QUERIES_TABLE ?? SystemTableNames.queries;
-  const wsEndpoint = process.env.WEBSOCKET_ENDPOINT ?? "";
-  const ddbClient = new DynamoDBClient({
-    region: process.env.AWS_REGION
+
+// ../server/src/handlers/lambda-handlers.ts
+function requiredTableName(configured, environmentName) {
+  const value = configured ?? process.env[environmentName];
+  if (!value) throw new Error(`${environmentName} must name a system table`);
+  return value;
+}
+function assertRequestKey(name, value, maxBytes) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > maxBytes) {
+    throw new Error(`${name} is not a valid DynamoDB key`);
+  }
+  return value;
+}
+function createLambdaHandlers(config = {}) {
+  const connectionsTable = requiredTableName(
+    config.connectionsTableName,
+    "CONNECTIONS_TABLE"
+  );
+  const dependenciesTable = requiredTableName(
+    config.dependenciesTableName,
+    "DEPENDENCIES_TABLE"
+  );
+  const queriesTable = requiredTableName(
+    config.queriesTableName,
+    "QUERIES_TABLE"
+  );
+  const apiGatewayEndpoint = config.apiGatewayEndpoint ?? process.env.WEBSOCKET_ENDPOINT ?? "";
+  const ddbClient = config.dbConfig?.client ?? new DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION,
+    endpoint: config.dbConfig?.endpoint
   });
-  const docClient = DynamoDBDocumentClient.from(ddbClient);
-  const utils = createStreamUtils({
+  const docClient = config.dbConfig?.docClient ?? DynamoDBDocumentClient.from(ddbClient, {
+    marshallOptions: { removeUndefinedValues: true }
+  });
+  const apiClient = config.apiClient ?? new ApiGatewayManagementApiClient({ endpoint: apiGatewayEndpoint });
+  const sharedConfig = {
+    dbConfig: { ...config.dbConfig, client: ddbClient, docClient },
+    apiClient,
+    apiGatewayEndpoint,
+    connectionsTableName: connectionsTable,
+    dependenciesTableName: dependenciesTable,
+    queriesTableName: queriesTable
+  };
+  const connect = createConnectHandler(sharedConfig);
+  const disconnect = createDisconnectHandler(sharedConfig);
+  const streamUtils = createStreamUtils({
     ddbClient,
     docClient,
-    apiGatewayEndpoint: wsEndpoint,
+    apiClient,
+    apiGatewayEndpoint,
     connectionsTable,
     dependenciesTable,
     queriesTable
   });
-  const getApiClient = () => new ApiGatewayManagementApiClient({
-    endpoint: wsEndpoint
-  });
   async function connectHandler(event) {
-    const connectionId = event.requestContext.connectionId;
-    const now = Date.now();
-    const ttl = Math.floor(now / 1e3) + 3600;
-    try {
-      const connectionEntry = {
-        connectionId,
-        context: event.requestContext.authorizer,
-        connectedAt: now,
-        ttl
-      };
-      await docClient.send(
-        new PutCommand({
-          TableName: connectionsTable,
-          Item: connectionEntry
-        })
-      );
-      info("Connection established:", connectionId);
-      return { statusCode: 200, body: "Connected" };
-    } catch (error$1) {
-      error("Error creating connection:", error$1);
-      return { statusCode: 500, body: "Failed to connect" };
-    }
+    const result = await connect({
+      requestContext: {
+        connectionId: event.requestContext.connectionId,
+        authorizer: event.requestContext.authorizer,
+        identity: event.requestContext.identity
+      }
+    });
+    return {
+      statusCode: result.statusCode,
+      body: result.statusCode === 200 ? "Connected" : "Failed to connect"
+    };
   }
   async function disconnectHandler(event) {
-    const connectionId = event.requestContext.connectionId;
-    try {
-      await utils.cleanupConnection(connectionId);
-      return { statusCode: 200, body: "Disconnected" };
-    } catch (error$1) {
-      error("Error removing connection:", error$1);
-      return { statusCode: 500, body: "Failed to disconnect" };
-    }
+    const result = await disconnect({
+      requestContext: { connectionId: event.requestContext.connectionId }
+    });
+    return {
+      statusCode: result.statusCode,
+      body: result.statusCode === 200 ? "Disconnected" : "Failed to disconnect"
+    };
   }
   async function messageHandler(event) {
     const connectionId = event.requestContext.connectionId;
     try {
+      assertRequestKey("connectionId", connectionId, 2048);
       const body = JSON.parse(event.body ?? "{}");
-      const { type, subscriptionId } = body;
       let response;
-      switch (type) {
-        case "init": {
-          response = {
-            type: "connected",
-            connectionId
-          };
-          break;
-        }
-        case "ping": {
-          response = {
-            type: "pong"
-          };
-          break;
-        }
-        case "unsubscribe": {
-          const subResponse = await docClient.send(
-            new GetCommand({
-              TableName: queriesTable,
-              Key: { pk: connectionId, sk: subscriptionId }
-            })
-          );
-          if (subResponse.Item) {
-            const queryEntry = subResponse.Item;
-            await Promise.all(
-              queryEntry.dependencies.map(
-                (key) => docClient.send(
-                  new DeleteCommand({
-                    TableName: dependenciesTable,
-                    Key: { pk: key, sk: `${connectionId}#${subscriptionId}` }
-                  })
-                )
-              )
-            );
-          }
-          await docClient.send(
-            new DeleteCommand({
-              TableName: queriesTable,
-              Key: { pk: connectionId, sk: subscriptionId }
-            })
-          );
-          response = { type: "result", data: { success: true } };
-          break;
-        }
-        default:
-          response = {
-            type: "error",
-            message: `Message type '${type}' should be handled by the app API route`
-          };
+      if (body.type === "init") {
+        response = { type: "connected", connectionId };
+      } else if (body.type === "ping") {
+        const now = Math.floor(Date.now() / 1e3);
+        await docClient.send(
+          new UpdateCommand({
+            TableName: connectionsTable,
+            Key: { connectionId },
+            UpdateExpression: "SET #ttl = :ttl",
+            ConditionExpression: "#status = :open AND #ttl > :now",
+            ExpressionAttributeNames: { "#status": "status", "#ttl": "ttl" },
+            ExpressionAttributeValues: {
+              ":open": "open",
+              ":now": now,
+              ":ttl": now + DEFAULT_CONNECTION_LEASE_SECONDS
+            }
+          })
+        );
+        response = { type: "pong" };
+      } else {
+        response = {
+          type: "error",
+          message: "Unsupported WebSocket message type"
+        };
       }
-      const apiClient = getApiClient();
       await apiClient.send(
         new PostToConnectionCommand({
           ConnectionId: connectionId,
@@ -1510,183 +2323,17 @@ function createLambdaHandlers() {
         })
       );
       return { statusCode: 200, body: "OK" };
-    } catch (error$1) {
-      error("Error handling message:", error$1);
+    } catch (error2) {
+      error("Error handling message:", error2);
       return { statusCode: 500, body: "Internal server error" };
     }
   }
   async function streamHandler(event) {
-    info(
-      `[stream] Processing ${event.Records.length} records from DynamoDB stream`
-    );
-    const affectedSubscriptions = /* @__PURE__ */ new Map();
-    const affectedKeys = /* @__PURE__ */ new Set();
-    for (const record of event.Records) {
-      if (!record.dynamodb) continue;
-      const tableName = extractTableName(record);
-      if (!tableName) continue;
-      const newImage = record.dynamodb.NewImage ? unmarshall(record.dynamodb.NewImage) : null;
-      const oldImage = record.dynamodb.OldImage ? unmarshall(record.dynamodb.OldImage) : null;
-      if (newImage) {
-        for (const key of extractAffectedKeys(tableName, newImage)) {
-          affectedKeys.add(key);
-        }
-      }
-      if (oldImage) {
-        for (const key of extractAffectedKeys(tableName, oldImage)) {
-          affectedKeys.add(key);
-        }
-      }
-    }
-    const lookupResults = await Promise.all(
-      [...affectedKeys].map((key) => utils.findAffectedSubscriptions(key))
-    );
-    for (const subscriptions of lookupResults) {
-      for (const sub of subscriptions) {
-        if (!affectedSubscriptions.has(sub.connectionId)) {
-          affectedSubscriptions.set(sub.connectionId, /* @__PURE__ */ new Set());
-        }
-        affectedSubscriptions.get(sub.connectionId).add(sub.subscriptionId);
-      }
-    }
-    let totalSubs = 0;
-    for (const [, subs] of affectedSubscriptions) {
-      totalSubs += subs.size;
-    }
-    info(
-      `[stream] Found ${affectedSubscriptions.size} affected connections, ${totalSubs} subscriptions`
-    );
-    const sendPromises = [];
-    for (const [connectionId, subscriptionIds] of affectedSubscriptions) {
-      for (const subscriptionId of subscriptionIds) {
-        sendPromises.push(
-          utils.processSubscription(connectionId, subscriptionId)
-        );
-      }
-    }
-    await Promise.allSettled(sendPromises);
-    info("[stream] Processing complete");
-  }
-  return {
-    connectHandler,
-    disconnectHandler,
-    messageHandler,
-    streamHandler
-  };
-}
-function evaluateFilter(filter, record) {
-  switch (filter.type) {
-    case "comparison":
-      return evaluateComparison(filter, record);
-    case "logical":
-      return evaluateLogical(filter, record);
-    case "function":
-      return evaluateFunction(filter, record);
-    default:
-      warn(`Unknown filter type: ${filter.type}`);
-      return false;
-  }
-}
-function evaluateFilters(filters, record) {
-  if (filters.length === 0) return true;
-  return filters.every((filter) => evaluateFilter(filter, record));
-}
-function evaluateComparison(filter, record) {
-  const { operator, field, value, value2 } = filter;
-  if (!field || !operator) return false;
-  const fieldValue = getFieldValue(record, field);
-  switch (operator) {
-    case "eq":
-      return fieldValue === value;
-    case "ne":
-      return fieldValue !== value;
-    case "gt":
-      return compareValues(fieldValue, value) > 0;
-    case "gte":
-      return compareValues(fieldValue, value) >= 0;
-    case "lt":
-      return compareValues(fieldValue, value) < 0;
-    case "lte":
-      return compareValues(fieldValue, value) <= 0;
-    case "between":
-      return compareValues(fieldValue, value) >= 0 && compareValues(fieldValue, value2) <= 0;
-    default:
-      warn(`Unknown comparison operator: ${operator}`);
-      return false;
+    return processStreamEvent(event, streamUtils);
   }
-}
-function evaluateLogical(filter, record) {
-  const { operator, conditions } = filter;
-  if (!operator || !conditions) return false;
-  switch (operator) {
-    case "and":
-      return conditions.every((c) => evaluateFilter(c, record));
-    case "or":
-      return conditions.some((c) => evaluateFilter(c, record));
-    case "not":
-      return conditions.length > 0 && !evaluateFilter(conditions[0], record);
-    default:
-      warn(`Unknown logical operator: ${operator}`);
-      return false;
-  }
-}
-function evaluateFunction(filter, record) {
-  const { operator, field, value } = filter;
-  if (!field || !operator) return false;
-  const fieldValue = getFieldValue(record, field);
-  switch (operator) {
-    case "beginsWith":
-      return typeof fieldValue === "string" && typeof value === "string" && fieldValue.startsWith(value);
-    case "contains":
-      return typeof fieldValue === "string" && typeof value === "string" && fieldValue.includes(value);
-    default:
-      warn(`Unknown function operator: ${operator}`);
-      return false;
-  }
-}
-function getFieldValue(record, field) {
-  const parts = field.split(".");
-  let value = record;
-  for (const part of parts) {
-    if (value === null || value === void 0) return void 0;
-    if (typeof value !== "object") return void 0;
-    value = value[part];
-  }
-  return value;
-}
-function compareValues(a, b) {
-  if (a === null || a === void 0) {
-    return b === null || b === void 0 ? 0 : -1;
-  }
-  if (b === null || b === void 0) {
-    return 1;
-  }
-  if (typeof a === "number" && typeof b === "number") {
-    return a - b;
-  }
-  if (typeof a === "string" && typeof b === "string") {
-    return a.localeCompare(b);
-  }
-  if (typeof a === "boolean" && typeof b === "boolean") {
-    return a === b ? 0 : a ? 1 : -1;
-  }
-  return String(a).localeCompare(String(b));
-}
-function sortRecords(records, sortField, sortOrder = "asc") {
-  if (!sortField) return records;
-  return [...records].sort((a, b) => {
-    const aValue = getFieldValue(a, sortField);
-    const bValue = getFieldValue(b, sortField);
-    const comparison = compareValues(aValue, bValue);
-    return sortOrder === "desc" ? -comparison : comparison;
-  });
-}
-function getRecordKey(record, pkField, skField) {
-  const pk = record[pkField];
-  const sk = skField ? record[skField] : void 0;
-  return sk !== void 0 ? `${pk}#${sk}` : String(pk);
+  return { connectHandler, disconnectHandler, messageHandler, streamHandler };
 }
 
-export { DependencyTracker, ProcedureBuilder, QueryBuilderImpl, Router, applyPatches, batchPatches, buildDeleteStatement, buildGetStatement, buildInsertStatement, buildSelectStatement, buildUpdateStatement, createConnectHandler, createDbContext, createDependencyKey, createDisconnectHandler, createFilterBuilder, createLambdaHandlers, createReactiveHandler, createRouter, createStreamHandler, evaluateFilter, evaluateFilters, executeProcedure, extractAffectedKeys, extractDependencies, generatePatches, getRecordKey, hasChanges, initReactive, isProcedure, mergeRouters, operationToQueryMetadata, optimizePatches, parseDependencyKey, sortRecords };
+export { InvalidInputError, SafeRequestError, createDbContext, createLambdaHandlers, createReactiveHandler, initReactive, isSafeRequestError };
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map