@yolo-labs/yolo-cli 0.23.0

package/dist/vendored/flexdb.mjs

@@ -0,0 +1,1087 @@
+// ../flexdb/src/error.ts
+var FlexDBError = class _FlexDBError extends Error {
+  /** Stable machine-readable code, e.g. `INVALID_COLLECTION_NAME`. */
+  code;
+  constructor(message, code = "FLEXDB_ERROR") {
+    super(message);
+    this.name = "FlexDBError";
+    this.code = code;
+    Object.setPrototypeOf(this, _FlexDBError.prototype);
+  }
+};
+
+// ../flexdb/src/sql.ts
+var COLLECTION_RE = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+var SEGMENT_RE = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+var DANGEROUS_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function assertCollectionName(name) {
+  if (typeof name !== "string" || !COLLECTION_RE.test(name)) {
+    throw new FlexDBError(
+      `Invalid collection name: ${JSON.stringify(name)}. Must match ${COLLECTION_RE.source}.`,
+      "INVALID_COLLECTION_NAME"
+    );
+  }
+}
+function assertFieldPath(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    throw new FlexDBError(
+      `Invalid field path: ${JSON.stringify(path)}. Must be a non-empty string.`,
+      "INVALID_FIELD_PATH"
+    );
+  }
+  const segments = path.split(".");
+  for (const seg of segments) {
+    if (!SEGMENT_RE.test(seg)) {
+      throw new FlexDBError(
+        `Invalid field path segment: ${JSON.stringify(seg)} in ${JSON.stringify(path)}. Each segment must match ${SEGMENT_RE.source}.`,
+        "INVALID_FIELD_PATH"
+      );
+    }
+    if (DANGEROUS_SEGMENTS.has(seg)) {
+      throw new FlexDBError(
+        `Reserved field path segment: ${JSON.stringify(seg)} in ${JSON.stringify(path)}.`,
+        "INVALID_FIELD_PATH"
+      );
+    }
+  }
+}
+function jsonPath(path) {
+  assertFieldPath(path);
+  return `$.${path}`;
+}
+function jsonExtract(path) {
+  return `json_extract(document, '${jsonPath(path)}')`;
+}
+function indexName(collection, fields) {
+  assertCollectionName(collection);
+  const parts = fields.map((f) => {
+    assertFieldPath(f);
+    return f.replace(/\./g, "_");
+  });
+  const hash = hashFields(fields);
+  return `idx_${collection}__${parts.join("__")}__${hash}`;
+}
+function hashFields(fields) {
+  const input = fields.join("\0");
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function assertNonNegativeInt(value, label) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || !Number.isSafeInteger(value)) {
+    throw new FlexDBError(
+      `Invalid ${label}: ${JSON.stringify(value)}. Must be a non-negative integer.`,
+      "INVALID_OPTION"
+    );
+  }
+  return value;
+}
+
+// ../flexdb/src/matcher.ts
+var KNOWN_FIELD_OPERATORS = /* @__PURE__ */ new Set([
+  "$eq",
+  "$ne",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  "$in",
+  "$nin",
+  "$exists",
+  "$regex",
+  "$options",
+  "$not"
+  // field-level $not negates an inner operator expression
+]);
+var LOGICAL_OPERATORS = /* @__PURE__ */ new Set(["$and", "$or", "$nor", "$not"]);
+var MISSING = Symbol("missing");
+function resolvePath(doc, path) {
+  const segments = path.split(".");
+  let current = doc;
+  for (const seg of segments) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return MISSING;
+    }
+    if (!Object.prototype.hasOwnProperty.call(current, seg)) {
+      return MISSING;
+    }
+    current = current[seg];
+  }
+  return current;
+}
+function typeRank(v) {
+  if (v === null || v === void 0) return 0;
+  if (typeof v === "number") return 1;
+  if (typeof v === "string") return 2;
+  if (typeof v === "boolean") return 3;
+  return 4;
+}
+function compareValues(a, b) {
+  const ra = typeRank(a);
+  const rb = typeRank(b);
+  if (ra !== rb) return ra - rb;
+  switch (ra) {
+    case 0:
+      return 0;
+    case 1: {
+      const na = a;
+      const nb = b;
+      if (na < nb) return -1;
+      if (na > nb) return 1;
+      return 0;
+    }
+    case 2: {
+      const sa = a;
+      const sb = b;
+      if (sa < sb) return -1;
+      if (sa > sb) return 1;
+      return 0;
+    }
+    case 3:
+      return a === b ? 0 : a ? 1 : -1;
+    default: {
+      const sa = JSON.stringify(a);
+      const sb = JSON.stringify(b);
+      if (sa < sb) return -1;
+      if (sa > sb) return 1;
+      return 0;
+    }
+  }
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b)) return false;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const ao = a;
+  const bo = b;
+  const ak = Object.keys(ao);
+  const bk = Object.keys(bo);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    if (!Object.prototype.hasOwnProperty.call(bo, k)) return false;
+    if (!deepEqual(ao[k], bo[k])) return false;
+  }
+  return true;
+}
+function equalsField(fieldValue, target) {
+  if (deepEqual(fieldValue, target)) return true;
+  if (Array.isArray(fieldValue)) {
+    return fieldValue.some((el) => deepEqual(el, target));
+  }
+  return false;
+}
+function rangeMatch(fieldValue, operand, pass) {
+  const test = (v) => typeRank(v) === typeRank(operand) && pass(compareValues(v, operand));
+  if (Array.isArray(fieldValue)) {
+    return fieldValue.some(test);
+  }
+  return test(fieldValue);
+}
+function buildRegex(spec) {
+  let source;
+  let flags = "";
+  if (typeof spec === "string") {
+    source = spec;
+  } else if (spec && typeof spec === "object" && "$regex" in spec) {
+    const obj = spec;
+    if (typeof obj.$regex !== "string") {
+      throw new FlexDBError("$regex must be a string", "INVALID_QUERY");
+    }
+    source = obj.$regex;
+    if (obj.$options !== void 0) {
+      if (typeof obj.$options !== "string") {
+        throw new FlexDBError("$options must be a string", "INVALID_QUERY");
+      }
+      flags = obj.$options;
+    }
+  } else {
+    throw new FlexDBError("$regex must be a string or { $regex, $options }", "INVALID_QUERY");
+  }
+  try {
+    return new RegExp(source, flags);
+  } catch (e) {
+    throw new FlexDBError(
+      `Invalid $regex: ${e instanceof Error ? e.message : String(e)}`,
+      "INVALID_QUERY"
+    );
+  }
+}
+function matchField(fieldValue, condition) {
+  const present = fieldValue !== MISSING;
+  const value = present ? fieldValue : void 0;
+  if (!isOperatorDoc(condition)) {
+    if (!present) return condition === null;
+    return equalsField(value, condition);
+  }
+  const ops = condition;
+  if ("$options" in ops && !("$regex" in ops)) {
+    throw new FlexDBError("$options is only valid alongside $regex", "INVALID_QUERY");
+  }
+  for (const [op, operand] of Object.entries(ops)) {
+    if (op === "$options") continue;
+    if (!KNOWN_FIELD_OPERATORS.has(op)) {
+      throw new FlexDBError(`Unknown query operator: ${op}`, "INVALID_QUERY");
+    }
+    switch (op) {
+      case "$eq":
+        if (!present) {
+          if (operand !== null) return false;
+        } else if (!equalsField(value, operand)) {
+          return false;
+        }
+        break;
+      case "$ne":
+        if (!present) {
+          if (operand === null) return false;
+        } else if (equalsField(value, operand)) {
+          return false;
+        }
+        break;
+      case "$gt":
+        if (!present || !rangeMatch(value, operand, (c) => c > 0)) return false;
+        break;
+      case "$gte":
+        if (!present || !rangeMatch(value, operand, (c) => c >= 0)) return false;
+        break;
+      case "$lt":
+        if (!present || !rangeMatch(value, operand, (c) => c < 0)) return false;
+        break;
+      case "$lte":
+        if (!present || !rangeMatch(value, operand, (c) => c <= 0)) return false;
+        break;
+      case "$in": {
+        if (!Array.isArray(operand)) {
+          throw new FlexDBError("$in requires an array", "INVALID_QUERY");
+        }
+        if (!present) {
+          if (!operand.some((t) => t === null)) return false;
+        } else if (!operand.some((t) => equalsField(value, t))) {
+          return false;
+        }
+        break;
+      }
+      case "$nin": {
+        if (!Array.isArray(operand)) {
+          throw new FlexDBError("$nin requires an array", "INVALID_QUERY");
+        }
+        if (!present) {
+          if (operand.some((t) => t === null)) return false;
+        } else if (operand.some((t) => equalsField(value, t))) {
+          return false;
+        }
+        break;
+      }
+      case "$exists": {
+        if (typeof operand !== "boolean") {
+          throw new FlexDBError("$exists requires a boolean", "INVALID_QUERY");
+        }
+        if (present !== operand) return false;
+        break;
+      }
+      case "$regex": {
+        const re = buildRegex(
+          "$options" in ops ? { $regex: operand, $options: ops.$options } : operand
+        );
+        if (!present) return false;
+        if (Array.isArray(value)) {
+          if (!value.some((el) => typeof el === "string" && re.test(el))) return false;
+        } else {
+          if (typeof value !== "string" || !re.test(value)) return false;
+        }
+        break;
+      }
+      case "$not": {
+        if (!isOperatorDoc(operand)) {
+          throw new FlexDBError(
+            "$not requires an operator expression (e.g. { $gte: 1 } or { $regex })",
+            "INVALID_QUERY"
+          );
+        }
+        if (matchField(fieldValue, operand)) return false;
+        break;
+      }
+      default:
+        throw new FlexDBError(`Unhandled query operator: ${op}`, "INVALID_QUERY");
+    }
+  }
+  return true;
+}
+function isOperatorDoc(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+  const keys = Object.keys(v);
+  if (keys.length === 0) return false;
+  return keys.every((k) => k.startsWith("$"));
+}
+function assertNonEmptyLogicalArray(op, condition) {
+  if (!Array.isArray(condition)) {
+    throw new FlexDBError(`${op} requires an array`, "INVALID_QUERY");
+  }
+  if (condition.length === 0) {
+    throw new FlexDBError(`${op} requires a non-empty array`, "INVALID_QUERY");
+  }
+}
+function assertSubQueryObject(op, value) {
+  if (!isPlainObject(value)) {
+    throw new FlexDBError(`${op} entries must be query objects`, "INVALID_QUERY");
+  }
+}
+function isPlainObject(v) {
+  if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function matchesQuery(doc, query) {
+  if (!query || typeof query !== "object") return true;
+  for (const [key, condition] of Object.entries(query)) {
+    if (key === "$options") {
+      throw new FlexDBError("$options is only valid alongside a field $regex", "INVALID_QUERY");
+    }
+    if (LOGICAL_OPERATORS.has(key)) {
+      switch (key) {
+        case "$and": {
+          assertNonEmptyLogicalArray("$and", condition);
+          if (!condition.every((sub) => matchesQuery(doc, sub))) return false;
+          break;
+        }
+        case "$or": {
+          assertNonEmptyLogicalArray("$or", condition);
+          if (!condition.some((sub) => matchesQuery(doc, sub))) return false;
+          break;
+        }
+        case "$nor": {
+          assertNonEmptyLogicalArray("$nor", condition);
+          if (condition.some((sub) => matchesQuery(doc, sub))) return false;
+          break;
+        }
+        case "$not": {
+          if (matchesQuery(doc, condition)) return false;
+          break;
+        }
+        default:
+          break;
+      }
+      continue;
+    }
+    if (key.startsWith("$")) {
+      throw new FlexDBError(`Unknown top-level operator: ${key}`, "INVALID_QUERY");
+    }
+    assertFieldPath(key);
+    const fieldValue = resolvePath(doc, key);
+    if (!matchField(fieldValue, condition)) {
+      return false;
+    }
+  }
+  return true;
+}
+function assertValidQuery(query) {
+  if (query === void 0 || query === null) return;
+  if (!isPlainObject(query)) {
+    throw new FlexDBError("Query must be a plain object", "INVALID_QUERY");
+  }
+  for (const [key, condition] of Object.entries(query)) {
+    if (key === "$options") {
+      throw new FlexDBError("$options is only valid alongside a field $regex", "INVALID_QUERY");
+    }
+    if (LOGICAL_OPERATORS.has(key)) {
+      if (key === "$not") {
+        assertSubQueryObject(key, condition);
+        assertValidQuery(condition);
+        continue;
+      }
+      assertNonEmptyLogicalArray(key, condition);
+      for (const sub of condition) {
+        assertSubQueryObject(key, sub);
+        assertValidQuery(sub);
+      }
+      continue;
+    }
+    if (key.startsWith("$")) {
+      throw new FlexDBError(`Unknown top-level operator: ${key}`, "INVALID_QUERY");
+    }
+    assertFieldPath(key);
+    assertValidFieldCondition(condition);
+  }
+}
+function assertValidFieldCondition(condition) {
+  if (!isOperatorDoc(condition)) return;
+  const ops = condition;
+  if ("$options" in ops && !("$regex" in ops)) {
+    throw new FlexDBError("$options is only valid alongside $regex", "INVALID_QUERY");
+  }
+  for (const [op, operand] of Object.entries(ops)) {
+    if (op === "$options") continue;
+    if (!KNOWN_FIELD_OPERATORS.has(op)) {
+      throw new FlexDBError(`Unknown query operator: ${op}`, "INVALID_QUERY");
+    }
+    if ((op === "$in" || op === "$nin") && !Array.isArray(operand)) {
+      throw new FlexDBError(`${op} requires an array`, "INVALID_QUERY");
+    }
+    if (op === "$exists" && typeof operand !== "boolean") {
+      throw new FlexDBError("$exists requires a boolean", "INVALID_QUERY");
+    }
+    if (op === "$not") {
+      if (!isOperatorDoc(operand)) {
+        throw new FlexDBError(
+          "$not requires an operator expression (e.g. { $gte: 1 } or { $regex })",
+          "INVALID_QUERY"
+        );
+      }
+      assertValidFieldCondition(operand);
+    }
+    if (op === "$regex") {
+      buildRegex("$options" in ops ? { $regex: operand, $options: ops.$options } : operand);
+    }
+  }
+}
+function sortDocuments(docs, sort) {
+  const entries = Object.entries(sort);
+  for (const [field, dir] of entries) {
+    assertFieldPath(field);
+    if (dir !== 1 && dir !== -1) {
+      throw new FlexDBError(
+        `Invalid sort direction for "${field}": ${JSON.stringify(dir)}. Use 1 or -1.`,
+        "INVALID_SORT"
+      );
+    }
+  }
+  return docs.sort((a, b) => {
+    for (const [field, dir] of entries) {
+      const av = resolvePath(a, field);
+      const bv = resolvePath(b, field);
+      const an = av === MISSING ? null : av;
+      const bn = bv === MISSING ? null : bv;
+      const cmp = compareValues(an, bn);
+      if (cmp !== 0) return dir === 1 ? cmp : -cmp;
+    }
+    return 0;
+  });
+}
+
+// ../flexdb/src/update.ts
+var UPDATE_OPERATORS = /* @__PURE__ */ new Set(["$set", "$unset", "$inc", "$push", "$pull", "$addToSet"]);
+function cloneValue(value) {
+  if (value === null || typeof value !== "object") return value;
+  return JSON.parse(JSON.stringify(value));
+}
+function isOwnTraversable(cur, seg) {
+  if (!Object.prototype.hasOwnProperty.call(cur, seg)) return false;
+  const next = cur[seg];
+  return next !== null && typeof next === "object" && !Array.isArray(next);
+}
+function defineOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, writable: true, enumerable: true, configurable: true });
+}
+function setPath(doc, path, value) {
+  const segs = path.split(".");
+  let cur = doc;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    if (!isOwnTraversable(cur, seg)) {
+      defineOwn(cur, seg, {});
+    }
+    cur = cur[seg];
+  }
+  defineOwn(cur, segs[segs.length - 1], cloneValue(value));
+}
+function unsetPath(doc, path) {
+  const segs = path.split(".");
+  let cur = doc;
+  for (let i = 0; i < segs.length - 1; i++) {
+    if (!isOwnTraversable(cur, segs[i])) return;
+    cur = cur[segs[i]];
+  }
+  delete cur[segs[segs.length - 1]];
+}
+function getPath(doc, path) {
+  const segs = path.split(".");
+  let cur = doc;
+  for (const seg of segs) {
+    if (cur === null || typeof cur !== "object" || Array.isArray(cur)) return void 0;
+    if (!Object.prototype.hasOwnProperty.call(cur, seg)) return void 0;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function validateUpdate(update) {
+  if (!update || typeof update !== "object" || Array.isArray(update)) {
+    throw new FlexDBError("Update must be an object of update operators", "INVALID_UPDATE");
+  }
+  const keys = Object.keys(update);
+  if (keys.length === 0) {
+    throw new FlexDBError("Update must contain at least one operator", "INVALID_UPDATE");
+  }
+  for (const k of keys) {
+    if (!UPDATE_OPERATORS.has(k)) {
+      throw new FlexDBError(
+        k.startsWith("$") ? `Unsupported update operator: ${k}` : `Update keys must be operators (got bare field "${k}"); use $set`,
+        "INVALID_UPDATE"
+      );
+    }
+    const v = update[k];
+    if (!v || typeof v !== "object" || Array.isArray(v)) {
+      throw new FlexDBError(`${k} must be an object`, "INVALID_UPDATE");
+    }
+    for (const path of Object.keys(v)) {
+      assertFieldPath(path);
+    }
+  }
+}
+function assertValidUpdate(update) {
+  applyUpdate({}, update);
+}
+function applyUpdate(doc, update) {
+  validateUpdate(update);
+  const result = JSON.parse(JSON.stringify(doc));
+  const originalId = result._id;
+  if (update.$set) {
+    for (const [path, value] of Object.entries(update.$set)) {
+      if (path === "_id") continue;
+      setPath(result, path, value);
+    }
+  }
+  if (update.$unset) {
+    for (const path of Object.keys(update.$unset)) {
+      if (path === "_id") continue;
+      unsetPath(result, path);
+    }
+  }
+  if (update.$inc) {
+    for (const [path, delta] of Object.entries(update.$inc)) {
+      if (typeof delta !== "number") {
+        throw new FlexDBError(`$inc on "${path}" requires a number`, "INVALID_UPDATE");
+      }
+      const current = getPath(result, path);
+      if (current === void 0 || current === null) {
+        setPath(result, path, delta);
+      } else if (typeof current === "number") {
+        setPath(result, path, current + delta);
+      } else {
+        throw new FlexDBError(`Cannot $inc non-numeric field "${path}"`, "INVALID_UPDATE");
+      }
+    }
+  }
+  if (update.$push) {
+    for (const [path, value] of Object.entries(update.$push)) {
+      const current = getPath(result, path);
+      if (current === void 0) {
+        setPath(result, path, [value]);
+      } else if (Array.isArray(current)) {
+        current.push(cloneValue(value));
+      } else {
+        throw new FlexDBError(`Cannot $push to non-array field "${path}"`, "INVALID_UPDATE");
+      }
+    }
+  }
+  if (update.$pull) {
+    for (const [path, value] of Object.entries(update.$pull)) {
+      const current = getPath(result, path);
+      if (current === void 0) continue;
+      if (!Array.isArray(current)) {
+        throw new FlexDBError(`Cannot $pull from non-array field "${path}"`, "INVALID_UPDATE");
+      }
+      const filtered = current.filter((el) => !deepEqual(el, value));
+      setPath(result, path, filtered);
+    }
+  }
+  if (update.$addToSet) {
+    for (const [path, value] of Object.entries(update.$addToSet)) {
+      const current = getPath(result, path);
+      if (current === void 0) {
+        setPath(result, path, [value]);
+      } else if (Array.isArray(current)) {
+        if (!current.some((el) => deepEqual(el, value))) {
+          current.push(cloneValue(value));
+        }
+      } else {
+        throw new FlexDBError(`Cannot $addToSet on non-array field "${path}"`, "INVALID_UPDATE");
+      }
+    }
+  }
+  defineOwn(result, "_id", originalId);
+  return result;
+}
+function applyUpsertFromUpdate(query, update, id) {
+  const seed = {};
+  const ctx = { id };
+  seedFromQuery(query, seed, ctx);
+  const applied = applyUpdate(seed, update);
+  defineOwn(applied, "_id", ctx.id);
+  return applied;
+}
+function seedFromQuery(query, seed, ctx) {
+  for (const [key, value] of Object.entries(query)) {
+    if (key === "$and") {
+      if (Array.isArray(value)) {
+        for (const sub of value) {
+          if (sub && typeof sub === "object" && !Array.isArray(sub)) {
+            seedFromQuery(sub, seed, ctx);
+          }
+        }
+      }
+      continue;
+    }
+    if (key.startsWith("$")) continue;
+    const eq = equalityValue(value);
+    if (eq === NO_EQUALITY) continue;
+    if (key === "_id") {
+      if (typeof eq !== "string") {
+        throw new FlexDBError(
+          `Cannot upsert with a non-string _id filter: ${JSON.stringify(eq)}. _id must be a string.`,
+          "INVALID_QUERY"
+        );
+      }
+      ctx.id = eq;
+      continue;
+    }
+    assertFieldPath(key);
+    setPath(seed, key, eq);
+  }
+}
+var NO_EQUALITY = Symbol("no-equality");
+function equalityValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 0) return value;
+  if (!keys.every((k) => k.startsWith("$"))) return value;
+  if ("$eq" in value) return value.$eq;
+  return NO_EQUALITY;
+}
+
+// ../flexdb/src/pushdown.ts
+var MAX_IN_PUSHDOWN = 90;
+function isPushableId(v) {
+  return typeof v === "string";
+}
+function analyzeQuery(query, _indexedPaths) {
+  const sqlClauses = [];
+  let fullyPushed = true;
+  const keys = Object.keys(query);
+  if (keys.length === 0) {
+    return { sqlClauses, fullyPushed: true };
+  }
+  for (const key of keys) {
+    if (key === "_id") {
+      const pushed = pushIdCondition(query[key], sqlClauses);
+      if (!pushed) fullyPushed = false;
+      continue;
+    }
+    fullyPushed = false;
+  }
+  return { sqlClauses, fullyPushed };
+}
+function pushIdCondition(condition, out) {
+  if (isPushableId(condition)) {
+    out.push({ sql: "id = ?", params: [condition] });
+    return true;
+  }
+  if (condition && typeof condition === "object" && !Array.isArray(condition)) {
+    const ops = condition;
+    const opKeys = Object.keys(ops);
+    if (opKeys.length === 1 && opKeys[0] === "$eq" && isPushableId(ops.$eq)) {
+      out.push({ sql: "id = ?", params: [ops.$eq] });
+      return true;
+    }
+    if (opKeys.length === 1 && opKeys[0] === "$in" && Array.isArray(ops.$in) && ops.$in.every(isPushableId)) {
+      const arr = ops.$in;
+      if (arr.length === 0) {
+        out.push({ sql: "0 = 1", params: [] });
+        return true;
+      }
+      if (arr.length > MAX_IN_PUSHDOWN) {
+        return false;
+      }
+      out.push({
+        sql: `id IN (${arr.map(() => "?").join(", ")})`,
+        params: arr
+      });
+      return true;
+    }
+  }
+  return false;
+}
+
+// ../flexdb/src/flexdb.ts
+var MAX_ROWS_PER_INSERT = 30;
+var MAX_IDS_PER_IN = 90;
+var MAX_STATEMENTS_PER_BATCH = 40;
+function assertWriteFilter(query) {
+  if (query === null || query === void 0) {
+    throw new FlexDBError("A filter is required for update/delete operations", "INVALID_QUERY");
+  }
+}
+function chunk(arr, size) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}
+var FlexDB = class {
+  #d1;
+  #initialized = false;
+  #initPromise = null;
+  constructor(d1) {
+    if (!d1 || typeof d1.prepare !== "function") {
+      throw new FlexDBError("FlexDB requires a D1Database binding", "INVALID_BINDING");
+    }
+    this.#d1 = d1;
+  }
+  /**
+   * Lazily create the table + base index. Idempotent and single-flight PER
+   * instance, so a long-lived (module-cached) handle runs the DDL once and then
+   * skips it on every subsequent request — see the README's handle-caching
+   * quickstart, which is how callers avoid per-request DDL (codex P2 r19).
+   */
+  async ensureInitialized() {
+    if (this.#initialized) return;
+    if (this.#initPromise) return this.#initPromise;
+    this.#initPromise = (async () => {
+      try {
+        await this.#d1.batch([
+          this.#d1.prepare(
+            `CREATE TABLE IF NOT EXISTS _flexdb_documents (
+               collection TEXT NOT NULL,
+               id TEXT NOT NULL,
+               document TEXT NOT NULL,
+               created_at INTEGER DEFAULT (strftime('%s','now')),
+               updated_at INTEGER DEFAULT (strftime('%s','now')),
+               PRIMARY KEY (collection, id)
+             )`
+          ),
+          this.#d1.prepare(
+            "CREATE INDEX IF NOT EXISTS idx_flexdb_documents_collection ON _flexdb_documents(collection)"
+          )
+        ]);
+        this.#initialized = true;
+      } catch (error) {
+        this.#initPromise = null;
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new FlexDBError(`FlexDB initialization failed: ${msg}`, "INIT_FAILED");
+      }
+    })();
+    return this.#initPromise;
+  }
+  /** Get a typed collection handle. Validates the name eagerly. */
+  collection(name, options) {
+    assertCollectionName(name);
+    if (options?.indexes) {
+      for (const f of options.indexes) assertFieldPath(f);
+    }
+    return new Collection(this.#d1, name, options, () => this.ensureInitialized());
+  }
+  /** The underlying D1 binding (escape hatch for power users). */
+  get d1() {
+    return this.#d1;
+  }
+};
+var Collection = class {
+  #db;
+  #name;
+  #indexes;
+  #ensureInit;
+  #indexesEnsured = null;
+  constructor(db, name, options, ensureInit) {
+    this.#db = db;
+    this.#name = name;
+    this.#indexes = new Set(options?.indexes ?? []);
+    this.#ensureInit = ensureInit;
+  }
+  async #ready() {
+    await this.#ensureInit();
+    if (this.#indexes.size > 0) {
+      if (!this.#indexesEnsured) {
+        this.#indexesEnsured = this.#createDeclaredIndexes();
+      }
+      await this.#indexesEnsured;
+    }
+  }
+  async #createDeclaredIndexes() {
+    for (const field of this.#indexes) {
+      await this.#createSingleFieldIndex(field);
+    }
+  }
+  async #createSingleFieldIndex(field) {
+    const name = indexName(this.#name, [field]);
+    const expr = jsonExtract(field);
+    await this.#db.prepare(
+      `CREATE INDEX IF NOT EXISTS ${name}
+           ON _flexdb_documents(collection, ${expr})`
+    ).run();
+  }
+  /** Declared-index set used for pushdown decisions. */
+  #indexedPaths() {
+    return this.#indexes;
+  }
+  // --- Inserts ---
+  async insertOne(doc) {
+    await this.#ready();
+    const id = crypto.randomUUID();
+    const stored = { ...doc, _id: id };
+    await this.#db.prepare("INSERT INTO _flexdb_documents (collection, id, document) VALUES (?, ?, ?)").bind(this.#name, id, JSON.stringify(stored)).run();
+    return { insertedId: id };
+  }
+  async insertMany(docs) {
+    await this.#ready();
+    if (!Array.isArray(docs)) {
+      throw new FlexDBError("insertMany requires an array of documents", "INVALID_ARGUMENT");
+    }
+    if (docs.length === 0) return { insertedIds: [] };
+    const insertedIds = [];
+    const rows = docs.map((doc) => {
+      const id = crypto.randomUUID();
+      insertedIds.push(id);
+      return { id, json: JSON.stringify({ ...doc, _id: id }) };
+    });
+    const statements = chunk(rows, MAX_ROWS_PER_INSERT).map((group) => {
+      const placeholders = group.map(() => "(?, ?, ?)").join(", ");
+      const params = [];
+      for (const r of group) params.push(this.#name, r.id, r.json);
+      return this.#db.prepare(`INSERT INTO _flexdb_documents (collection, id, document) VALUES ${placeholders}`).bind(...params);
+    });
+    await this.#runBatched(statements);
+    return { insertedIds };
+  }
+  // --- Reads ---
+  async findOne(query) {
+    const results = await this.#execute(query ?? {}, { limit: 1 });
+    return results.length > 0 ? results[0] : null;
+  }
+  find(query, options) {
+    return new FlexFindCursor(
+      query ?? {},
+      options ?? {},
+      (q, o) => this.#execute(q, o)
+    );
+  }
+  async countDocuments(query) {
+    await this.#ready();
+    const q = query ?? {};
+    assertValidQuery(q);
+    const plan = analyzeQuery(q, this.#indexedPaths());
+    if (plan.fullyPushed) {
+      const { sql, params } = this.#buildSelect(plan, { count: true });
+      const row = await this.#db.prepare(sql).bind(...params).first();
+      return row?.n ?? 0;
+    }
+    const docs = await this.#execute(q, {});
+    return docs.length;
+  }
+  // --- Updates ---
+  async updateOne(query, update) {
+    await this.#ready();
+    assertWriteFilter(query);
+    assertValidUpdate(update);
+    const doc = await this.findOne(query);
+    if (!doc) return { matchedCount: 0, modifiedCount: 0 };
+    const updated = applyUpdate(doc, update);
+    if (deepEqual(doc, updated)) return { matchedCount: 1, modifiedCount: 0 };
+    await this.#writeDocument(doc._id, updated);
+    return { matchedCount: 1, modifiedCount: 1 };
+  }
+  async updateMany(query, update) {
+    await this.#ready();
+    assertWriteFilter(query);
+    assertValidUpdate(update);
+    const docs = await this.#execute(query, {});
+    if (docs.length === 0) return { matchedCount: 0, modifiedCount: 0 };
+    const statements = [];
+    for (const doc of docs) {
+      const updated = applyUpdate(doc, update);
+      if (deepEqual(doc, updated)) continue;
+      statements.push(
+        this.#db.prepare(
+          `UPDATE _flexdb_documents SET document = ?, updated_at = strftime('%s','now')
+               WHERE collection = ? AND id = ?`
+        ).bind(JSON.stringify(updated), this.#name, doc._id)
+      );
+    }
+    await this.#runBatched(statements);
+    return { matchedCount: docs.length, modifiedCount: statements.length };
+  }
+  async findOneAndUpdate(query, update, options) {
+    await this.#ready();
+    assertWriteFilter(query);
+    assertValidUpdate(update);
+    const doc = await this.findOne(query);
+    if (!doc) {
+      if (options?.upsert) {
+        const created = applyUpsertFromUpdate(query, update, crypto.randomUUID());
+        await this.#db.prepare("INSERT INTO _flexdb_documents (collection, id, document) VALUES (?, ?, ?)").bind(this.#name, created._id, JSON.stringify(created)).run();
+        return created;
+      }
+      return null;
+    }
+    const updated = applyUpdate(doc, update);
+    if (!deepEqual(doc, updated)) {
+      await this.#writeDocument(doc._id, updated);
+    }
+    return updated;
+  }
+  // --- Deletes ---
+  async deleteOne(query) {
+    await this.#ready();
+    assertWriteFilter(query);
+    const doc = await this.findOne(query);
+    if (!doc) return { deletedCount: 0 };
+    await this.#db.prepare("DELETE FROM _flexdb_documents WHERE collection = ? AND id = ?").bind(this.#name, doc._id).run();
+    return { deletedCount: 1 };
+  }
+  async deleteMany(query) {
+    await this.#ready();
+    assertWriteFilter(query);
+    const docs = await this.#execute(query, {});
+    if (docs.length === 0) return { deletedCount: 0 };
+    const ids = docs.map((doc) => doc._id);
+    const statements = chunk(ids, MAX_IDS_PER_IN).map(
+      (group) => this.#db.prepare(
+        `DELETE FROM _flexdb_documents WHERE collection = ? AND id IN (${group.map(() => "?").join(", ")})`
+      ).bind(this.#name, ...group)
+    );
+    await this.#runBatched(statements);
+    return { deletedCount: ids.length };
+  }
+  // --- Indexing ---
+  async createIndex(fields) {
+    await this.#ensureInit();
+    if (!Array.isArray(fields) || fields.length === 0) {
+      throw new FlexDBError("createIndex requires a non-empty array of field paths", "INVALID_ARGUMENT");
+    }
+    for (const f of fields) assertFieldPath(f);
+    if (fields.length === 1) {
+      this.#indexes.add(fields[0]);
+      await this.#createSingleFieldIndex(fields[0]);
+      return;
+    }
+    const name = indexName(this.#name, fields);
+    const exprs = fields.map((f) => jsonExtract(f)).join(", ");
+    await this.#db.prepare(`CREATE INDEX IF NOT EXISTS ${name} ON _flexdb_documents(collection, ${exprs})`).run();
+    for (const f of fields) this.#indexes.add(f);
+  }
+  // --- Internals ---
+  async #writeDocument(id, doc) {
+    await this.#db.prepare(
+      `UPDATE _flexdb_documents SET document = ?, updated_at = strftime('%s','now')
+           WHERE collection = ? AND id = ?`
+    ).bind(JSON.stringify(doc), this.#name, id).run();
+  }
+  /** Run statements in batches under D1's per-invocation statement cap. */
+  async #runBatched(statements) {
+    for (const group of chunk(statements, MAX_STATEMENTS_PER_BATCH)) {
+      if (group.length > 0) await this.#db.batch(group);
+    }
+  }
+  /**
+   * Build the SELECT (or COUNT) statement for a pushdown plan. Only validated
+   * identifiers are interpolated; every value is parameter-bound.
+   */
+  #buildSelect(plan, opts = {}) {
+    const projection = opts.count ? "COUNT(*) AS n" : "document";
+    let sql = `SELECT ${projection} FROM _flexdb_documents WHERE collection = ?`;
+    const params = [this.#name];
+    for (const clause of plan.sqlClauses) {
+      sql += ` AND ${clause.sql}`;
+      params.push(...clause.params);
+    }
+    return { sql, params };
+  }
+  /**
+   * The query executor behind findOne/find/count helpers.
+   *
+   * Pushdown + the LIMIT fix:
+   *  - Field conditions on INDEXED paths with SQL-mappable operators are pushed
+   *    into the SELECT (`AND json_extract(...) <op> ?`), plus the `_id` PK
+   *    fast-path. The `_id` and indexed-eq pushes let SQLite use indexes.
+   *  - SQL LIMIT/OFFSET are appended ONLY when the WHOLE query was pushed down
+   *    (`plan.fullyPushed`) AND there is no JS sort. Otherwise we fetch all
+   *    rows the SQL prefilter matched, run the full matcher in JS, sort, and
+   *    THEN apply skip/limit in JS — fixing the upstream bug where LIMIT ran
+   *    before the JS filter and returned too few documents.
+   */
+  async #execute(query, options) {
+    await this.#ready();
+    assertValidQuery(query);
+    const plan = analyzeQuery(query, this.#indexedPaths());
+    const skip = options.skip !== void 0 ? assertNonNegativeInt(options.skip, "skip") : 0;
+    const limit = options.limit !== void 0 ? assertNonNegativeInt(options.limit, "limit") : void 0;
+    const hasSort = !!options.sort && Object.keys(options.sort).length > 0;
+    const canPushPagination = plan.fullyPushed && !hasSort;
+    const { sql: baseSql, params } = this.#buildSelect(plan);
+    let sql = baseSql;
+    if (canPushPagination) {
+      if (limit !== void 0) {
+        sql += ` LIMIT ${limit}`;
+        if (skip > 0) sql += ` OFFSET ${skip}`;
+      } else if (skip > 0) {
+        sql += ` LIMIT -1 OFFSET ${skip}`;
+      }
+    }
+    const result = await this.#db.prepare(sql).bind(...params).all();
+    const rows = result.results ?? [];
+    let docs = [];
+    for (const row of rows) {
+      let parsed;
+      try {
+        parsed = JSON.parse(row.document);
+      } catch {
+        continue;
+      }
+      docs.push(parsed);
+    }
+    if (!plan.fullyPushed) {
+      docs = docs.filter((doc) => matchesQuery(doc, query));
+    }
+    if (hasSort) {
+      docs = sortDocuments(docs, options.sort);
+    }
+    if (!canPushPagination) {
+      if (skip > 0) docs = docs.slice(skip);
+      if (limit !== void 0) docs = docs.slice(0, limit);
+    }
+    return docs;
+  }
+};
+var FlexFindCursor = class {
+  #query;
+  #options;
+  #executor;
+  constructor(query, options, executor) {
+    this.#query = query;
+    this.#options = { ...options };
+    this.#executor = executor;
+  }
+  sort(sort) {
+    this.#options.sort = sort;
+    return this;
+  }
+  limit(limit) {
+    this.#options.limit = limit;
+    return this;
+  }
+  skip(skip) {
+    this.#options.skip = skip;
+    return this;
+  }
+  toArray() {
+    return this.#executor(this.#query, this.#options);
+  }
+  then(onfulfilled, onrejected) {
+    return this.toArray().then(onfulfilled, onrejected);
+  }
+};
+export {
+  Collection,
+  FlexDB,
+  FlexDBError
+};