dynamodb-reactive 0.1.21 → 0.2.1

package/dist/server.cjs

@@ -0,0 +1,2351 @@
+'use strict';
+
+var clientDynamodb = require('@aws-sdk/client-dynamodb');
+var libDynamodb = require('@aws-sdk/lib-dynamodb');
+var crypto = require('crypto');
+var zod = require('zod');
+var utilDynamodb = require('@aws-sdk/util-dynamodb');
+var util = require('util');
+var clientApigatewaymanagementapi = require('@aws-sdk/client-apigatewaymanagementapi');
+var jsonpatch = require('fast-json-patch');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var jsonpatch__default = /*#__PURE__*/_interopDefault(jsonpatch);
+
+// ../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 {
+  inputSchema;
+  constructor(inputSchema) {
+    this.inputSchema = inputSchema;
+  }
+  /**
+   * Define the input schema for the procedure
+   */
+  input(schema) {
+    return new _ProcedureBuilder(schema);
+  }
+  /**
+   * Define a query procedure (read-only operation)
+   */
+  query(resolver) {
+    return {
+      type: "query",
+      inputSchema: this.inputSchema,
+      resolver
+    };
+  }
+  /**
+   * Define a mutation procedure (write operation)
+   */
+  mutation(resolver) {
+    return {
+      type: "mutation",
+      inputSchema: this.inputSchema,
+      resolver
+    };
+  }
+};
+function isProcedure(value) {
+  return typeof value === "object" && value !== null && "type" in value && "resolver" in value && (value.type === "query" || value.type === "mutation");
+}
+async function executeProcedure(procedure, ctx, rawInput) {
+  let input;
+  if (procedure.inputSchema) {
+    const parseResult = procedure.inputSchema.safeParse(rawInput);
+    if (!parseResult.success) {
+      throw new InvalidInputError();
+    }
+    input = parseResult.data;
+  } else {
+    input = rawInput;
+  }
+  return procedure.resolver({ ctx, input });
+}
+
+// ../server/src/router.ts
+var Router = class {
+  definition;
+  constructor(definition) {
+    this.definition = definition;
+  }
+  /**
+   * Get a procedure by its path (e.g., "todos.list")
+   */
+  getProcedure(path) {
+    const parts = path.split(".");
+    let current = this.definition;
+    for (const part of parts) {
+      if (typeof current !== "object" || current === null) {
+        return null;
+      }
+      current = current[part];
+    }
+    if (isProcedure(current)) {
+      return current;
+    }
+    return null;
+  }
+  /**
+   * Execute a procedure by its path
+   */
+  async execute(path, ctx, input) {
+    const procedure = this.getProcedure(path);
+    if (!procedure) {
+      throw new Error(`Procedure not found: ${path}`);
+    }
+    return executeProcedure(procedure, ctx, input);
+  }
+};
+function createRouter(definition) {
+  return new Router(definition);
+}
+
+// ../server/src/reactive.ts
+function initReactive() {
+  return {
+    procedure: new ProcedureBuilder(),
+    router(definition) {
+      return createRouter(definition);
+    }
+  };
+}
+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": {
+      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 === "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)}`
+        });
+      }
+      return { dependencies, safe: dependencies.length === 1 };
+    }
+    case "logical": {
+      if (condition.operator === "not" || !condition.conditions || condition.conditions.length === 0) {
+        return { dependencies, safe: false };
+      }
+      let safe = true;
+      for (const subCondition of condition.conditions) {
+        const extracted = extractFromCondition(
+          tableName,
+          subCondition
+        );
+        dependencies.push(...extracted.dependencies);
+        safe &&= extracted.safe;
+      }
+      return { dependencies, safe };
+    }
+  }
+  return { dependencies, safe: false };
+}
+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 (!safe) dependencies.push(wildcardDependency(operation.tableName));
+  const unique = /* @__PURE__ */ new Map();
+  for (const dependency of dependencies) {
+    unique.set(createDependencyKey(dependency), dependency);
+  }
+  return [...unique.values()];
+}
+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 = crypto.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 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 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 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
+var FilterBuilderImpl = class {
+  eq(field, value) {
+    return { type: "comparison", operator: "eq", field: field.fieldName, value };
+  }
+  ne(field, value) {
+    return { type: "comparison", operator: "ne", field: field.fieldName, value };
+  }
+  gt(field, value) {
+    return { type: "comparison", operator: "gt", field: field.fieldName, value };
+  }
+  gte(field, value) {
+    return { type: "comparison", operator: "gte", field: field.fieldName, value };
+  }
+  lt(field, value) {
+    return { type: "comparison", operator: "lt", field: field.fieldName, value };
+  }
+  lte(field, value) {
+    return { type: "comparison", operator: "lte", field: field.fieldName, value };
+  }
+  between(field, lower, upper) {
+    return {
+      type: "function",
+      operator: "between",
+      field: field.fieldName,
+      value: lower,
+      value2: upper
+    };
+  }
+  beginsWith(field, prefix) {
+    return {
+      type: "function",
+      operator: "beginsWith",
+      field: field.fieldName,
+      value: prefix
+    };
+  }
+  contains(field, substring) {
+    return {
+      type: "function",
+      operator: "contains",
+      field: field.fieldName,
+      value: substring
+    };
+  }
+  and(...conditions) {
+    return { type: "logical", operator: "and", conditions };
+  }
+  or(...conditions) {
+    return { type: "logical", operator: "or", conditions };
+  }
+  not(condition) {
+    return { type: "logical", operator: "not", conditions: [condition] };
+  }
+};
+var QueryBuilderImpl = class {
+  table;
+  filters = [];
+  indexName;
+  limit;
+  ascending = true;
+  sortRequested = false;
+  executor;
+  operationTracker;
+  constructor(table, executor, operationTracker) {
+    this.table = table;
+    this.executor = executor;
+    this.operationTracker = operationTracker;
+  }
+  filter(fn) {
+    const builder = new FilterBuilderImpl();
+    const condition = fn(builder);
+    this.filters.push(condition);
+    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;
+  }
+  sortAscending() {
+    this.ascending = true;
+    this.sortRequested = true;
+    return this;
+  }
+  sortDescending() {
+    this.ascending = false;
+    this.sortRequested = true;
+    return this;
+  }
+  async execute() {
+    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: index?.name,
+      indexPkField: index?.pk,
+      indexSkField: index?.sk,
+      ...sortField ? { sortField, sortOrder: this.ascending ? "asc" : "desc" } : {},
+      limit: this.limit
+    };
+  }
+};
+var FilterConditionSchema = zod.z.lazy(() => {
+  const comparison = zod.z.object({
+    type: zod.z.literal("comparison"),
+    operator: zod.z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+    field: zod.z.string().min(1),
+    value: zod.z.unknown()
+  }).strict();
+  const queryFunction = zod.z.union([
+    zod.z.object({
+      type: zod.z.literal("function"),
+      operator: zod.z.literal("between"),
+      field: zod.z.string().min(1),
+      value: zod.z.unknown(),
+      value2: zod.z.unknown()
+    }).strict(),
+    zod.z.object({
+      type: zod.z.literal("function"),
+      operator: zod.z.enum(["beginsWith", "contains"]),
+      field: zod.z.string().min(1),
+      value: zod.z.unknown()
+    }).strict()
+  ]);
+  const logical = zod.z.object({
+    type: zod.z.literal("logical"),
+    operator: zod.z.enum(["and", "or", "not"]),
+    conditions: zod.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 zod.z.union([comparison, queryFunction, logical]);
+});
+var QueryMetadataSchema = zod.z.object({
+  planVersion: zod.z.literal(1),
+  tableName: zod.z.string().min(1),
+  indexName: zod.z.string().min(1).optional(),
+  indexPkField: zod.z.string().min(1).optional(),
+  indexSkField: zod.z.string().min(1).optional(),
+  filterConditions: zod.z.array(FilterConditionSchema),
+  sortField: zod.z.string().min(1).optional(),
+  sortOrder: zod.z.enum(["asc", "desc"]).optional(),
+  limit: zod.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 = zod.z.object({
+  generation: zod.z.number().int().nonnegative(),
+  fromVersion: zod.z.number().int().nonnegative(),
+  toVersion: zod.z.number().int().positive(),
+  messageId: zod.z.string().min(1)
+});
+var PendingDeliverySchema = zod.z.discriminatedUnion("type", [
+  DeliveryVersionSchema.extend({
+    type: zod.z.literal("patch"),
+    patches: zod.z.array(
+      zod.z.object({
+        op: zod.z.enum(["add", "remove", "replace", "move", "copy", "test"]),
+        path: zod.z.string(),
+        value: zod.z.unknown().optional(),
+        from: zod.z.string().optional()
+      })
+    )
+  }),
+  DeliveryVersionSchema.extend({
+    type: zod.z.literal("resync")
+  }).strict()
+]);
+var SystemSchemas = {
+  /**
+   * ReactiveConnectionsV2 - Tracks active WebSocket connections
+   */
+  connections: zod.z.object({
+    connectionId: zod.z.string(),
+    status: zod.z.enum(["open", "closed"]),
+    context: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+    authorizerContext: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+    requestIdentity: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+    connectedAt: zod.z.number(),
+    ttl: zod.z.number()
+  }),
+  /**
+   * ReactiveDependenciesV2 - The inverted index for O(1) lookups
+   */
+  dependencies: zod.z.object({
+    pk: zod.z.string(),
+    // Versioned encoded dependency key
+    sk: zod.z.string(),
+    // ConnectionID#SubscriptionID
+    connectionId: zod.z.string(),
+    subscriptionId: zod.z.string(),
+    tableName: zod.z.string(),
+    fieldName: zod.z.string(),
+    fieldValue: zod.z.string(),
+    generation: zod.z.number().int().nonnegative(),
+    registrationId: zod.z.string().min(1),
+    ttl: zod.z.number()
+  }),
+  /**
+   * ReactiveConnectionQueriesV2 - Stores subscription state for diffing
+   */
+  queries: zod.z.object({
+    pk: zod.z.string(),
+    // ConnectionID
+    sk: zod.z.string(),
+    // SubscriptionID
+    connectionId: zod.z.string(),
+    subscriptionId: zod.z.string(),
+    status: zod.z.enum(["registering", "active", "cancelled", "faulted"]),
+    generation: zod.z.number().int().nonnegative(),
+    registrationId: zod.z.string().min(1),
+    queryMetadata: QueryMetadataSchema,
+    lastResult: zod.z.array(zod.z.unknown()),
+    dependencies: zod.z.array(zod.z.string()),
+    version: zod.z.number().int().nonnegative(),
+    pendingDelivery: PendingDeliverySchema.optional(),
+    createdAt: zod.z.number(),
+    updatedAt: zod.z.number(),
+    ttl: zod.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 clientDynamodb.ExecuteStatementCommand(compileQueryMetadata(metadata, nextToken))
+    );
+    items.push(
+      ...(response.Items ?? []).map(
+        (item) => utilDynamodb.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
+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 clientDynamodb.DynamoDBClient({
+    region: config.region ?? process.env.AWS_REGION ?? "us-east-1",
+    endpoint: config.endpoint
+  });
+  const docClient = config.docClient ?? libDynamodb.DynamoDBDocumentClient.from(client, {
+    marshallOptions: {
+      removeUndefinedValues: true,
+      convertEmptyValues: false
+    },
+    unmarshallOptions: {
+      wrapNumbers: false
+    }
+  });
+  return { client, docClient };
+}
+function createDbContext(config, dependencyTracker) {
+  const { client, docClient } = createClients(config);
+  async function executeQuery(operation) {
+    return executeQueryMetadata(
+      client,
+      operationToQueryMetadata(operation)
+    );
+  }
+  return {
+    query(table) {
+      return new QueryBuilderImpl(
+        table,
+        executeQuery,
+        dependencyTracker?.track.bind(dependencyTracker)
+      );
+    },
+    async get(table, key) {
+      const command = new libDynamodb.GetCommand({
+        TableName: table.tableName,
+        Key: key,
+        ConsistentRead: true
+      });
+      const response = await docClient.send(command);
+      return response.Item ? response.Item : null;
+    },
+    async put(table, item) {
+      const parsedItem = table.validate(item);
+      const command = new libDynamodb.PutCommand({
+        TableName: table.tableName,
+        Item: parsedItem
+      });
+      await docClient.send(command);
+    },
+    async delete(table, key) {
+      const command = new libDynamodb.DeleteCommand({
+        TableName: table.tableName,
+        Key: key
+      });
+      await docClient.send(command);
+    },
+    async update(table, key, updates) {
+      const currentResponse = await docClient.send(
+        new libDynamodb.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 = {};
+      for (const [i, field] of fields.entries()) {
+        const nameKey = `#f${i}`;
+        expressionAttributeNames[nameKey] = field;
+        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})`);
+        }
+      }
+      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 libDynamodb.PutCommand({
+        TableName: table.tableName,
+        Item: parsed,
+        ConditionExpression: conditionExpression,
+        ...Object.keys(expressionAttributeNames).length ? { ExpressionAttributeNames: expressionAttributeNames } : {},
+        ...Object.keys(expressionAttributeValues).length ? { ExpressionAttributeValues: expressionAttributeValues } : {}
+      });
+      await docClient.send(command);
+      return parsed;
+    }
+  };
+}
+
+// ../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"
+    };
+  }
+  if (value && typeof value === "object") return { valueType: "object" };
+  return value;
+}
+function logger(method) {
+  return (...values) => consoleLogger[method](...values.map(sanitized));
+}
+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 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"
+    );
+  }
+}
+function validateKeyString(name, value, maxBytes) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw requestError(`${name} must be a non-empty string`, 400);
+  }
+  if (Buffer.byteLength(value, "utf8") > maxBytes) {
+    throw requestError(`${name} exceeds DynamoDB's UTF-8 key length limit`, 400);
+  }
+}
+function validateRequest(request) {
+  validateKeyString(
+    "connectionId",
+    request.connectionId,
+    DYNAMODB_PARTITION_KEY_MAX_BYTES2
+  );
+  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);
+    }
+  }
+}
+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) {
+  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 = config.dbConfig?.client ?? new clientDynamodb.DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION,
+    endpoint: config.dbConfig?.endpoint
+  });
+  const docClient = config.dbConfig?.docClient ?? libDynamodb.DynamoDBDocumentClient.from(ddbClient, {
+    marshallOptions: { removeUndefinedValues: true }
+  });
+  const dbConfig = {
+    ...config.dbConfig,
+    client: ddbClient,
+    docClient
+  };
+  async function authorize(requestInfo, context) {
+    const response = await docClient.send(
+      new libDynamodb.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 libDynamodb.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 {
+      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);
+      }
+      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: safeError?.message ?? "Internal server error",
+        code: safeError?.statusCode ?? 500,
+        ..."subscriptionId" in request ? { subscriptionId: request.subscriptionId } : {}
+      };
+    }
+  }
+  async function activeSnapshot(request) {
+    const response = await docClient.send(
+      new libDynamodb.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,
+      context,
+      request.input
+    );
+    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 || !util.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 registering = {
+      pk: request.connectionId,
+      sk: request.subscriptionId,
+      connectionId: request.connectionId,
+      subscriptionId: request.subscriptionId,
+      status: "registering",
+      generation: request.generation,
+      registrationId: request.registrationId,
+      queryMetadata,
+      lastResult: [],
+      dependencies: dependencyKeys,
+      version: 0,
+      createdAt: now,
+      updatedAt: now,
+      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 libDynamodb.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 libDynamodb.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 libDynamodb.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 libDynamodb.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 libDynamodb.GetCommand({
+          TableName: queriesTable,
+          Key: { pk: request.connectionId, sk: request.subscriptionId },
+          ConsistentRead: true
+        })
+      ),
+      docClient.send(
+        new libDynamodb.GetCommand({
+          TableName: connectionsTable,
+          Key: { connectionId: request.connectionId },
+          ConsistentRead: true
+        })
+      )
+    ]);
+    const query2 = queryResponse.Item;
+    const currentConnection = SystemSchemas.connections.safeParse(
+      connectionResponse.Item
+    );
+    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: query2.subscriptionId,
+      generation: query2.generation,
+      version: query2.version,
+      data: query2.lastResult
+    };
+  }
+  async function faultRegistration(request) {
+    await docClient.send(
+      new libDynamodb.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 libDynamodb.GetCommand({
+        TableName: queriesTable,
+        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 libDynamodb.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()
+        }
+      })
+    );
+    await Promise.all(
+      query2.dependencies.map(async (key) => {
+        try {
+          await docClient.send(
+            new libDynamodb.DeleteCommand({
+              TableName: dependenciesTable,
+              Key: {
+                pk: key,
+                sk: `${request.connectionId}#${request.subscriptionId}`
+              },
+              ConditionExpression: "#generation = :generation",
+              ExpressionAttributeNames: { "#generation": "generation" },
+              ExpressionAttributeValues: { ":generation": request.generation }
+            })
+          );
+        } catch (error2) {
+          if (!(error2 instanceof Error) || error2.name !== "ConditionalCheckFailedException") {
+            throw error2;
+          }
+        }
+      })
+    );
+    return { type: "result", data: { success: true } };
+  }
+  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: await config.router.execute(request.path, context, request.input)
+    };
+  }
+  async function registerConnection(connectionId, context) {
+    validateKeyString(
+      "connectionId",
+      connectionId,
+      DYNAMODB_PARTITION_KEY_MAX_BYTES2
+    );
+    const now = Date.now();
+    await docClient.send(
+      new libDynamodb.PutCommand({
+        TableName: connectionsTable,
+        Item: {
+          connectionId,
+          status: "open",
+          context,
+          connectedAt: now,
+          ttl: Math.floor(now / 1e3) + ttlSeconds
+        }
+      })
+    );
+  }
+  async function unregisterConnection(connectionId) {
+    validateKeyString(
+      "connectionId",
+      connectionId,
+      DYNAMODB_PARTITION_KEY_MAX_BYTES2
+    );
+    await docClient.send(
+      new libDynamodb.UpdateCommand({
+        TableName: connectionsTable,
+        Key: { connectionId },
+        UpdateExpression: "SET #status = :closed",
+        ConditionExpression: "attribute_exists(connectionId)",
+        ExpressionAttributeNames: { "#status": "status" },
+        ExpressionAttributeValues: { ":closed": "closed" }
+      })
+    );
+    let lastKey;
+    do {
+      const response = await docClient.send(
+        new libDynamodb.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 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(() => void 0, {
+        get(_target, property) {
+          return buildProxy([...path, property]);
+        },
+        apply(_target, _thisArg, args) {
+          return query(path.join("."), args[0]);
+        }
+      });
+    }
+    return buildProxy();
+  }
+  return {
+    handleRequest,
+    registerConnection,
+    unregisterConnection,
+    query,
+    createCaller
+  };
+}
+var { compare } = jsonpatch__default.default;
+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";
+  }
+};
+function extractTableName(record) {
+  const match = record.eventSourceARN?.match(/table\/([^/]+)/);
+  return match?.[1] ?? null;
+}
+function isConditionalFailure(error2) {
+  return error2 instanceof Error && error2.name === "ConditionalCheckFailedException";
+}
+function createStreamUtils(config) {
+  const {
+    ddbClient,
+    docClient,
+    connectionsTable,
+    dependenciesTable,
+    queriesTable
+  } = config;
+  let apiClient = config.apiClient;
+  function getApiClient() {
+    apiClient ??= new clientApigatewaymanagementapi.ApiGatewayManagementApiClient({
+      endpoint: config.apiGatewayEndpoint
+    });
+    return apiClient;
+  }
+  async function findAffectedSubscriptions(dependencyKey) {
+    const subscriptions = [];
+    let lastKey;
+    do {
+      const response = await docClient.send(
+        new libDynamodb.QueryCommand({
+          TableName: dependenciesTable,
+          KeyConditionExpression: "pk = :pk",
+          ExpressionAttributeValues: { ":pk": dependencyKey },
+          ConsistentRead: true,
+          ExclusiveStartKey: lastKey
+        })
+      );
+      subscriptions.push(
+        ...(response.Items ?? []).map((item) => ({
+          connectionId: item.connectionId,
+          subscriptionId: item.subscriptionId
+        }))
+      );
+      lastKey = response.LastEvaluatedKey;
+    } while (lastKey);
+    return subscriptions;
+  }
+  async function executeQueryFromMetadata(metadata) {
+    return executeQueryMetadata(ddbClient, metadata);
+  }
+  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 clientApigatewaymanagementapi.PostToConnectionCommand({
+        ConnectionId: query.connectionId,
+        Data: Buffer.from(JSON.stringify(deliveryMessage(query, delivery)))
+      })
+    );
+  }
+  async function clearDelivery(query, delivery) {
+    try {
+      await docClient.send(
+        new libDynamodb.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 (error2) {
+      if (!isConditionalFailure(error2)) throw error2;
+    }
+  }
+  async function cleanupSubscriptionDependencies(query) {
+    await Promise.all(
+      query.dependencies.map(async (dependency) => {
+        try {
+          await docClient.send(
+            new libDynamodb.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 {
+      for (let attempt = 0; attempt < MAX_PROCESS_ATTEMPTS; attempt++) {
+        const response = await docClient.send(
+          new libDynamodb.GetCommand({
+            TableName: queriesTable,
+            Key: { pk: connectionId, sk: subscriptionId },
+            ConsistentRead: true
+          })
+        );
+        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;
+        }
+        if (query.status === "registering") {
+          if (query.createdAt <= Date.now() - REGISTRATION_WINDOW_MS) {
+            try {
+              await docClient.send(
+                new libDynamodb.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: crypto.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 libDynamodb.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 libDynamodb.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;
+      }
+      throw new RetryableSubscriptionError(
+        `Subscription ${connectionId}/${subscriptionId} delivery did not settle`
+      );
+    } catch (error2) {
+      if (error2 instanceof clientApigatewaymanagementapi.GoneException) {
+        await cleanupConnection(connectionId);
+        return;
+      }
+      throw error2;
+    }
+  }
+  async function cleanupConnection(connectionId) {
+    try {
+      await docClient.send(
+        new libDynamodb.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 libDynamodb.QueryCommand({
+          TableName: queriesTable,
+          KeyConditionExpression: "pk = :pk",
+          ExpressionAttributeValues: { ":pk": connectionId },
+          ConsistentRead: true,
+          ExclusiveStartKey: lastKey
+        })
+      );
+      for (const item of response.Items ?? []) {
+        const query = item;
+        if (query.status !== "cancelled") {
+          try {
+            await docClient.send(
+              new libDynamodb.UpdateCommand({
+                TableName: queriesTable,
+                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()
+                }
+              })
+            );
+          } catch (error2) {
+            if (!isConditionalFailure(error2)) throw error2;
+            continue;
+          }
+        }
+        await cleanupSubscriptionDependencies(query);
+      }
+      lastKey = response.LastEvaluatedKey;
+    } while (lastKey);
+  }
+  return {
+    findAffectedSubscriptions,
+    executeQueryFromMetadata,
+    sendDelivery,
+    processSubscription,
+    cleanupConnection
+  };
+}
+
+// ../server/src/handlers/stream-handler.ts
+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);
+      }
+    }
+  );
+  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 = utilDynamodb.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
+      );
+    }
+  }
+  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
+        };
+      }
+    }
+  );
+  return {
+    batchItemFailures: results.filter(
+      (failure) => failure !== null
+    )
+  };
+}
+function clients(config) {
+  const ddbClient = config.dbConfig?.client ?? new clientDynamodb.DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION,
+    endpoint: config.dbConfig?.endpoint
+  });
+  const docClient = config.dbConfig?.docClient ?? libDynamodb.DynamoDBDocumentClient.from(ddbClient, {
+    marshallOptions: { removeUndefinedValues: true }
+  });
+  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();
+    try {
+      assertConnectionId(connectionId);
+      const authorizerContext = jsonSafeRecord(event.requestContext.authorizer);
+      const requestIdentity = jsonSafeRecord(event.requestContext.identity);
+      const connectionEntry = {
+        connectionId,
+        status: "open",
+        ...authorizerContext ? { authorizerContext } : {},
+        ...requestIdentity ? { requestIdentity } : {},
+        connectedAt: now,
+        ttl: Math.floor(now / 1e3) + DEFAULT_CONNECTION_LEASE_SECONDS
+      };
+      await docClient.send(
+        new libDynamodb.PutCommand({ TableName: connectionsTable, Item: connectionEntry })
+      );
+      debug("[stream] Connection established");
+      return { statusCode: 200 };
+    } 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;
+  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) {
+    try {
+      const connectionId = event.requestContext.connectionId;
+      assertConnectionId(connectionId);
+      await utils.cleanupConnection(connectionId);
+      return { statusCode: 200 };
+    } catch (error2) {
+      error("Error removing connection:", error2);
+      return { statusCode: 500 };
+    }
+  };
+}
+
+// ../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 clientDynamodb.DynamoDBClient({
+    region: config.dbConfig?.region ?? process.env.AWS_REGION,
+    endpoint: config.dbConfig?.endpoint
+  });
+  const docClient = config.dbConfig?.docClient ?? libDynamodb.DynamoDBDocumentClient.from(ddbClient, {
+    marshallOptions: { removeUndefinedValues: true }
+  });
+  const apiClient = config.apiClient ?? new clientApigatewaymanagementapi.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,
+    apiClient,
+    apiGatewayEndpoint,
+    connectionsTable,
+    dependenciesTable,
+    queriesTable
+  });
+  async function connectHandler(event) {
+    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 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 ?? "{}");
+      let response;
+      if (body.type === "init") {
+        response = { type: "connected", connectionId };
+      } else if (body.type === "ping") {
+        const now = Math.floor(Date.now() / 1e3);
+        await docClient.send(
+          new libDynamodb.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"
+        };
+      }
+      await apiClient.send(
+        new clientApigatewaymanagementapi.PostToConnectionCommand({
+          ConnectionId: connectionId,
+          Data: Buffer.from(JSON.stringify(response))
+        })
+      );
+      return { statusCode: 200, body: "OK" };
+    } catch (error2) {
+      error("Error handling message:", error2);
+      return { statusCode: 500, body: "Internal server error" };
+    }
+  }
+  async function streamHandler(event) {
+    return processStreamEvent(event, streamUtils);
+  }
+  return { connectHandler, disconnectHandler, messageHandler, streamHandler };
+}
+
+exports.InvalidInputError = InvalidInputError;
+exports.SafeRequestError = SafeRequestError;
+exports.createDbContext = createDbContext;
+exports.createLambdaHandlers = createLambdaHandlers;
+exports.createReactiveHandler = createReactiveHandler;
+exports.initReactive = initReactive;
+exports.isSafeRequestError = isSafeRequestError;
+//# sourceMappingURL=server.cjs.map
+//# sourceMappingURL=server.cjs.map