@asaidimu/anansi 1.1.0

package/index.js

@@ -0,0 +1,3170 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types/migrations.ts
+var migrations_exports = {};
+
+// src/types/persistence.ts
+var persistence_exports = {};
+
+// src/types/registry.ts
+var registry_exports = {};
+
+// src/types/schema-definition.ts
+var schema_definition_exports = {};
+
+// src/lib/persistence/index.ts
+var persistence_exports2 = {};
+__export(persistence_exports2, {
+  default: () => createEphemeralPersistence
+});
+import { createEventBus as createEventBus2 } from "@asaidimu/events";
+
+// src/lib/persistence/collection.ts
+import { createEventBus } from "@asaidimu/events";
+import {
+  createMatcher,
+  createPaginator,
+  createProjector,
+  createSorter
+} from "@asaidimu/query";
+
+// src/tools/patch.ts
+var patch_exports = {};
+__export(patch_exports, {
+  JsonPatchError: () => JsonPatchError,
+  applyPatch: () => applyPatch,
+  createPatch: () => createPatch,
+  normalizePath: () => normalizePath,
+  schemaChangeToPatch: () => schemaChangeToPatch
+});
+var JsonPatchError = class extends Error {
+  constructor(message, operation) {
+    super(message);
+    this.operation = operation;
+    this.name = "JsonPatchError";
+  }
+};
+function parseJsonPointer(path) {
+  const normalized = normalizePath(path);
+  if (normalized === "") return [];
+  return normalized.substring(1).split("/").map(unescapeJsonPointer);
+}
+function normalizePath(path) {
+  if (path === "" || path === "/") return "";
+  if (path.startsWith("/")) {
+    return "/" + path.substring(1).split("/").map(escapeJsonPointer).join("/");
+  }
+  return "/" + path.split(".").map(escapeJsonPointer).join("/");
+}
+function escapeJsonPointer(part) {
+  return part.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapeJsonPointer(part) {
+  return part.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+var pathCache = /* @__PURE__ */ new Map();
+function navigateTo(obj, parts) {
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object") {
+      throw new JsonPatchError(`Invalid path - parent not found at ${part}`);
+    }
+    if (Array.isArray(current)) {
+      const index = part === "-" ? current.length : parseInt(part);
+      if (isNaN(index) || index < 0 || index > current.length) {
+        throw new JsonPatchError(`Invalid array index: ${part}`);
+      }
+      current = current[index];
+    } else {
+      if (!current.hasOwnProperty(part)) {
+        throw new JsonPatchError(`Property ${part} not found`);
+      }
+      current = current[part];
+    }
+  }
+  return current;
+}
+function getValueAtPath(obj, path) {
+  const parts = pathCache.get(path) || parseJsonPointer(path);
+  pathCache.set(path, parts);
+  if (parts.length === 0) return obj;
+  const parent = navigateTo(obj, parts.slice(0, -1));
+  const key = parts[parts.length - 1];
+  if (Array.isArray(parent)) {
+    const index = parseInt(key);
+    if (isNaN(index) || index < 0 || index >= parent.length) {
+      throw new JsonPatchError(`Invalid array index: ${key}`);
+    }
+    return parent[index];
+  }
+  return parent[key];
+}
+function applyRemoveValue(obj, path, value) {
+  const parts = pathCache.get(path) || parseJsonPointer(path);
+  pathCache.set(path, parts);
+  const parent = navigateTo(obj, parts.slice(0, -1));
+  const key = parts[parts.length - 1];
+  if (Array.isArray(parent)) {
+    parent.splice(0, parent.length, ...parent.filter((item) => item !== value));
+  } else {
+    if (parent[key] === value) {
+      delete parent[key];
+    }
+  }
+  return obj;
+}
+function applyAdd(obj, path, value) {
+  const parts = pathCache.get(path) || parseJsonPointer(path);
+  pathCache.set(path, parts);
+  if (parts.length === 0) return value;
+  const parentPath = parts.slice(0, -1);
+  const key = parts[parts.length - 1];
+  const parent = navigateTo(obj, parentPath);
+  if (Array.isArray(parent)) {
+    if (key === "-") {
+      parent.push(value);
+    } else {
+      const index = parseInt(key);
+      if (index < 0 || index > parent.length) {
+        throw new JsonPatchError(`Invalid array index: ${key}`);
+      }
+      parent.splice(index, 0, value);
+    }
+  } else {
+    parent[key] = value;
+  }
+  return obj;
+}
+function applyRemove(obj, path) {
+  const parts = pathCache.get(path) || parseJsonPointer(path);
+  pathCache.set(path, parts);
+  if (parts.length === 0) return void 0;
+  const parent = navigateTo(obj, parts.slice(0, -1));
+  const key = parts[parts.length - 1];
+  if (Array.isArray(parent)) {
+    const index = parseInt(key);
+    parent.splice(index, 1);
+  } else {
+    delete parent[key];
+  }
+  return obj;
+}
+function applyPatch(target, patches) {
+  let result = JSON.parse(JSON.stringify(target));
+  for (const patch of patches) {
+    try {
+      switch (patch.op) {
+        case "add":
+          result = applyAdd(result, patch.path, patch.value);
+          break;
+        case "remove":
+          result = applyRemove(result, patch.path);
+          break;
+        case "removeValue":
+          result = applyRemoveValue(result, patch.path, patch.value);
+          break;
+        case "replace":
+          result = applyAdd(
+            applyRemove(result, patch.path),
+            patch.path,
+            patch.value
+          );
+          break;
+        case "copy": {
+          const value = getValueAtPath(result, patch.from);
+          result = applyAdd(
+            result,
+            patch.path,
+            JSON.parse(JSON.stringify(value))
+          );
+          break;
+        }
+        case "move": {
+          const value = getValueAtPath(result, patch.from);
+          result = applyAdd(result, patch.path, value);
+          result = applyRemove(result, patch.from);
+          break;
+        }
+        case "test": {
+          const actual = getValueAtPath(result, patch.path);
+          if (JSON.stringify(actual) !== JSON.stringify(patch.value)) {
+            throw new JsonPatchError("Test operation failed");
+          }
+          break;
+        }
+        default:
+          throw new JsonPatchError(
+            `Unsupported operation: ${patch.op}`
+          );
+      }
+    } catch (error) {
+      if (error instanceof JsonPatchError) {
+        error.operation = patch;
+      }
+      throw error;
+    }
+  }
+  return result;
+}
+function createPatch(oldObj, newObj) {
+  const patches = [];
+  generatePatches(oldObj, newObj, "", patches);
+  return patches;
+}
+function generatePatches(oldObj, newObj, path, patches) {
+  if (oldObj === newObj) return;
+  if (typeof oldObj !== typeof newObj || Array.isArray(oldObj) !== Array.isArray(newObj)) {
+    patches.push({ op: "replace", path, value: newObj });
+    return;
+  }
+  if (typeof oldObj === "object" && oldObj !== null) {
+    if (Array.isArray(oldObj)) {
+      handleArrays(oldObj, newObj, path, patches);
+    } else {
+      handleObjects(oldObj, newObj, path, patches);
+    }
+  } else if (oldObj !== newObj) {
+    patches.push({ op: "replace", path, value: newObj });
+  }
+}
+function handleArrays(oldArr, newArr, path, patches) {
+  const maxLen = Math.max(oldArr.length, newArr.length);
+  for (let i = 0; i < maxLen; i++) {
+    const currentPath = `${path}/${i}`;
+    if (i >= oldArr.length) {
+      patches.push({ op: "add", path: `${path}/-`, value: newArr[i] });
+    } else if (i >= newArr.length) {
+      patches.push({ op: "remove", path: currentPath });
+    } else {
+      generatePatches(oldArr[i], newArr[i], currentPath, patches);
+    }
+  }
+}
+function handleObjects(oldObj, newObj, path, patches) {
+  const seen = /* @__PURE__ */ new Set();
+  const oldKeys = Object.keys(oldObj);
+  const newKeys = Object.keys(newObj);
+  for (const key of oldKeys) {
+    const escapedKey = escapeJsonPointer(key);
+    const currentPath = path ? `${path}/${escapedKey}` : `/${escapedKey}`;
+    if (!newObj.hasOwnProperty(key)) {
+      patches.push({ op: "remove", path: currentPath });
+    } else {
+      generatePatches(
+        oldObj[key],
+        newObj[key],
+        currentPath,
+        patches
+      );
+      seen.add(key);
+    }
+  }
+  for (const key of newKeys) {
+    if (!seen.has(key)) {
+      const escapedKey = escapeJsonPointer(key);
+      const currentPath = path ? `${path}/${escapedKey}` : `/${escapedKey}`;
+      patches.push({
+        op: "add",
+        path: currentPath,
+        value: newObj[key]
+      });
+    }
+  }
+}
+function schemaChangeToPatch(change, schema) {
+  const patches = [];
+  switch (change.type) {
+    case "addField":
+      patches.push({
+        op: "add",
+        path: `/fields/${change.name}`,
+        value: change.definition
+      });
+      break;
+    case "removeField":
+      patches.push({
+        op: "remove",
+        path: `/fields/${change.name}`
+      });
+      break;
+    case "modifyField": {
+      const fieldPath = `/fields/${change.name}`;
+      Object.entries(change.changes).forEach(([key, value]) => {
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          patches.push({
+            op: "replace",
+            path: `${fieldPath}/${key}`,
+            value
+          });
+        } else {
+          patches.push({
+            op: "replace",
+            path: `${fieldPath}/${key}`,
+            value
+          });
+        }
+      });
+      break;
+    }
+    case "deprecateField":
+      patches.push({
+        op: "add",
+        path: `/fields/${change.name}/deprecated`,
+        value: true
+      });
+      break;
+    case "addIndex":
+      if (!schema.indexes) {
+        patches.push({
+          op: "add",
+          path: "/indexes",
+          value: []
+        });
+      }
+      patches.push({
+        op: "add",
+        path: "/indexes/-",
+        value: change.definition
+      });
+      break;
+    case "removeIndex": {
+      const indexIndex = schema.indexes?.findIndex(
+        (idx) => idx.name === change.name
+      );
+      if (indexIndex !== void 0 && indexIndex >= 0) {
+        patches.push({
+          op: "remove",
+          path: `/indexes/${indexIndex}`
+        });
+      }
+      break;
+    }
+    case "modifyIndex": {
+      const indexIndex = schema.indexes?.findIndex(
+        (idx) => idx.name === change.name
+      );
+      if (indexIndex !== void 0 && indexIndex >= 0) {
+        Object.entries(change.changes).forEach(([key, value]) => {
+          patches.push({
+            op: "replace",
+            path: `/indexes/${indexIndex}/${key}`,
+            value
+          });
+        });
+      }
+      break;
+    }
+    case "addConstraint":
+      if (!schema.constraints) {
+        patches.push({
+          op: "add",
+          path: "/constraints",
+          value: []
+        });
+      }
+      if (Array.isArray(change.constraint)) {
+        change.constraint.forEach((constraint) => {
+          patches.push({
+            op: "add",
+            path: "/constraints/-",
+            value: constraint
+          });
+        });
+      } else {
+        patches.push({
+          op: "add",
+          path: "/constraints/-",
+          value: change.constraint
+        });
+      }
+      break;
+    case "removeConstraint": {
+      const constraintIndex = schema.constraints?.findIndex(
+        (c) => Array.isArray(c) ? c.some((rule) => rule.name === change.name) : c.name === change.name
+      );
+      if (constraintIndex !== void 0 && constraintIndex >= 0) {
+        patches.push({
+          op: "remove",
+          path: `/constraints/${constraintIndex}`
+        });
+      }
+      break;
+    }
+    case "modifyConstraint": {
+      const constraintPath = findConstraintPath(schema, change.name);
+      if (constraintPath) {
+        Object.entries(change.changes).forEach(([key, value]) => {
+          patches.push({
+            op: "replace",
+            path: `${constraintPath}/${key}`,
+            value
+          });
+        });
+      }
+      break;
+    }
+  }
+  return patches;
+}
+function findConstraintPath(schema, name) {
+  if (!schema.constraints) return null;
+  for (let i = 0; i < schema.constraints.length; i++) {
+    const constraint = schema.constraints[i];
+    if (constraint.name === name) {
+      return `/constraints/${i}`;
+    }
+    if (isConstraintGroup(constraint)) {
+      const path = searchRules(constraint.rules, name);
+      if (path) {
+        return `/constraints/${i}${path}`;
+      }
+    }
+  }
+  return null;
+}
+function isConstraintGroup(obj) {
+  return obj && "operator" in obj && "rules" in obj;
+}
+function searchRules(rules, name) {
+  for (let i = 0; i < rules.length; i++) {
+    const rule = rules[i];
+    if ("name" in rule && rule.name === name) {
+      return `/rules/${i}`;
+    }
+    if (isConstraintGroup(rule)) {
+      const path = searchRules(rule.rules, name);
+      if (path) {
+        return `/rules/${i}${path}`;
+      }
+    }
+  }
+  return null;
+}
+
+// src/tools/merge.ts
+var merge_exports = {};
+__export(merge_exports, {
+  deepMerge: () => deepMerge
+});
+function deepMerge(target, update) {
+  const output = { ...target };
+  if (isObject(target) && isObject(update)) {
+    Object.keys(update).forEach((key) => {
+      if (isObject(update[key])) {
+        if (!(key in target)) {
+          Object.assign(output, { [key]: update[key] });
+        } else {
+          output[key] = deepMerge(
+            target[key],
+            update[key]
+          );
+        }
+      } else {
+        Object.assign(output, { [key]: update[key] });
+      }
+    });
+  }
+  return output;
+}
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+
+// src/tools/validator.ts
+var validator_exports = {};
+__export(validator_exports, {
+  createStandardSchemaValidator: () => createStandardSchemaValidator
+});
+function createStandardSchemaValidator(schema, constraintsMap) {
+  const validateTypeWithErrors = (value, fieldName, fieldDef, path) => {
+    const issues = [];
+    switch (fieldDef.type) {
+      case "string":
+        if (typeof value !== "string") {
+          issues.push({
+            message: `Expected type string but received ${typeof value}.`,
+            path
+          });
+        }
+        break;
+      case "number":
+        if (typeof value !== "number") {
+          issues.push({
+            message: `Expected type number but received ${typeof value}.`,
+            path
+          });
+        }
+        break;
+      case "boolean":
+        if (typeof value !== "boolean") {
+          issues.push({
+            message: `Expected type boolean but received ${typeof value}.`,
+            path
+          });
+        }
+        break;
+      case "array":
+        if (!Array.isArray(value)) {
+          issues.push({
+            message: `Expected an array but received ${typeof value}.`,
+            path
+          });
+        } else if (!fieldDef.itemsType) {
+          issues.push({
+            message: `Expected itemsType for array ${fieldName}`,
+            path
+          });
+        } else {
+          value.forEach((item, index) => {
+            issues.push(
+              ...validateTypeWithErrors(
+                item,
+                `Array: ${fieldName}`,
+                {
+                  type: fieldDef.itemsType,
+                  nestedSchema: fieldDef.nestedSchema
+                },
+                [...path, index]
+              )
+            );
+          });
+        }
+        break;
+      case "object":
+        if (typeof value !== "object" || value === null) {
+          issues.push({
+            message: `Expected an object but received ${value === null ? "null" : typeof value}.`,
+            path
+          });
+        } else if (fieldDef.nestedSchema) {
+          const nestedSchema = {
+            name: fieldDef.description ? `${fieldDef.description}-schema` : "nested-schema",
+            version: "1.0",
+            fields: fieldDef.nestedSchema
+          };
+          issues.push(
+            ...validateData(
+              nestedSchema,
+              value,
+              path
+            )
+          );
+        }
+        break;
+      case "dynamic":
+        break;
+      default:
+        issues.push({ message: `Unknown field type: ${fieldDef.type}`, path });
+        break;
+    }
+    return issues;
+  };
+  const validateFieldConstraints = (fieldName, fieldDef, data, path) => {
+    const issues = [];
+    if (!fieldDef.constraints) return issues;
+    fieldDef.constraints.forEach((constraint) => {
+      const predicate = constraintsMap[constraint.predicate];
+      if (!predicate) {
+        issues.push({
+          message: `Missing predicate for constraint: ${constraint.name}`,
+          path
+        });
+      } else {
+        const valid = constraint.type === "schema" ? predicate({ data, arguments: constraint.parameters }) : predicate({
+          data,
+          field: fieldName,
+          arguments: constraint.parameters
+        });
+        if (!valid) {
+          issues.push({
+            message: `Constraint '${constraint.name}' failed for field '${fieldName}'.`,
+            path
+          });
+        }
+      }
+    });
+    return issues;
+  };
+  const validateField = (fieldName, fieldDef, value, data, path) => {
+    return [
+      ...validateTypeWithErrors(value, fieldName, fieldDef, path),
+      ...validateFieldConstraints(fieldName, fieldDef, data, path)
+    ];
+  };
+  const evaluateRuleWithErrors = (rule, data, fieldName) => {
+    if ("operator" in rule) {
+      return applyLogicalOperator(
+        rule.operator,
+        rule.rules.map((r) => evaluateRuleWithErrors(r, data, fieldName))
+      );
+    }
+    const predicate = constraintsMap[rule.predicate];
+    if (!predicate) {
+      return false;
+    }
+    return rule.type === "schema" ? predicate({ data, field: rule.field, arguments: rule.parameters }) : predicate({ data, field: fieldName, arguments: rule.parameters });
+  };
+  const applyLogicalOperator = (operator, results) => {
+    switch (operator) {
+      case "and":
+        return results.every(Boolean);
+      case "or":
+        return results.some(Boolean);
+      case "not":
+        return results.length === 1 ? !results[0] : false;
+      case "nor":
+        return !results.some(Boolean);
+      case "xor":
+        return results.filter(Boolean).length === 1;
+      default:
+        console.error(`Unknown logical operator: ${operator}`);
+        return false;
+    }
+  };
+  const ruleToString = (rule) => {
+    if ("operator" in rule) {
+      return `(${rule.rules.map(ruleToString).join(` ${rule.operator} `)})`;
+    }
+    return rule.name;
+  };
+  const validateData = (schemaToValidate, data, path = []) => {
+    const issues = [];
+    for (const [fieldName, fieldDef] of Object.entries(schemaToValidate.fields)) {
+      if (fieldDef.required && data[fieldName] === void 0) {
+        issues.push({
+          message: `Field '${fieldName}' is required.`,
+          path: [...path, fieldName]
+        });
+      }
+    }
+    for (const [fieldName, fieldDef] of Object.entries(schemaToValidate.fields)) {
+      const value = data[fieldName];
+      if (value === void 0) continue;
+      issues.push(
+        ...validateField(fieldName, fieldDef, value, data, [...path, fieldName])
+      );
+    }
+    if (schemaToValidate.constraints) {
+      schemaToValidate.constraints.forEach((rule) => {
+        if (!evaluateRuleWithErrors(rule, data)) {
+          issues.push({
+            message: `Schema constraint failed: ${ruleToString(rule)}`,
+            path
+          });
+        }
+      });
+    }
+    return issues;
+  };
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "@asaidimu/anansi",
+      validate: (value) => {
+        if (typeof value !== "object" || value === null) {
+          return {
+            issues: [{ message: "Value must be a non-null object", path: [] }]
+          };
+        }
+        const issues = validateData(schema, value);
+        if (issues.length === 0) {
+          return { value };
+        }
+        return { issues };
+      }
+    }
+  };
+}
+
+// src/lib/migration/index.ts
+var migration_exports = {};
+__export(migration_exports, {
+  MigrationError: () => MigrationError,
+  MigrationErrorCode: () => MigrationErrorCode,
+  default: () => MigrationEngine
+});
+
+// src/lib/schema/validator.ts
+import { z } from "zod";
+
+// src/lib/schema/error.ts
+var SchemaValidationError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "SchemaValidationError";
+  }
+};
+
+// src/lib/schema/validator.ts
+var LogicalOperatorSchema = z.enum(["and", "or", "not", "nor", "xor"]);
+var FieldTypeSchema = z.enum(["string", "number", "boolean", "array", "object", "dynamic"]);
+var IndexTypeSchema = z.enum(["normal", "unique", "btree", "hash", "spatial", "fulltext", "gi", "expression", "composite"]);
+var ConstraintParametersSchema = z.custom(() => {
+  return true;
+});
+var ConstraintSchema = z.object({
+  type: z.string().optional(),
+  name: z.string(),
+  predicate: z.string().optional(),
+  parameters: ConstraintParametersSchema.optional(),
+  description: z.string().optional(),
+  field: z.string().optional(),
+  errorMessage: z.string().optional()
+});
+var ConstraintGroupSchema = z.object({
+  operator: LogicalOperatorSchema,
+  rules: z.array(z.union([ConstraintSchema, z.lazy(() => ConstraintGroupSchema)]))
+});
+var FieldDefinitionSchema = z.object({
+  type: FieldTypeSchema,
+  required: z.boolean().optional(),
+  constraints: z.array(ConstraintSchema).optional(),
+  default: z.any().optional(),
+  itemsType: FieldTypeSchema.optional(),
+  nestedSchema: z.record(z.lazy(() => FieldDefinitionSchema)).optional(),
+  deprecated: z.boolean().optional(),
+  reference: z.object({ schema: z.string(), field: z.string() }).optional(),
+  description: z.string().optional(),
+  unique: z.boolean().optional()
+});
+var PartialIndexConditionSchema = z.object({
+  operator: LogicalOperatorSchema,
+  field: z.string(),
+  value: z.any().optional(),
+  conditions: z.array(z.lazy(() => PartialIndexConditionSchema)).optional()
+});
+var IndexDefinitionSchema = z.object({
+  fields: z.array(z.string()),
+  type: IndexTypeSchema,
+  unique: z.boolean().optional(),
+  partial: PartialIndexConditionSchema.optional(),
+  description: z.string().optional(),
+  order: z.enum(["asc", "desc"]).optional(),
+  name: z.string().optional()
+});
+var SchemaConstraintSchema = z.array(z.union([ConstraintSchema, ConstraintGroupSchema]));
+var SchemaDefinitionSchema = z.object({
+  name: z.string(),
+  version: z.string(),
+  description: z.string().optional(),
+  fields: z.record(FieldDefinitionSchema),
+  indexes: z.array(IndexDefinitionSchema).optional(),
+  constraints: SchemaConstraintSchema.optional(),
+  metadata: z.record(z.any()).optional(),
+  dependencies: z.array(z.string()).optional(),
+  migrations: z.array(z.any()).optional()
+});
+var SchemaChangeSchema = z.union([
+  z.object({ type: z.literal("addField"), name: z.string(), definition: FieldDefinitionSchema }),
+  z.object({ type: z.literal("removeField"), name: z.string() }),
+  z.object({ type: z.literal("modifyField"), name: z.string(), changes: FieldDefinitionSchema.partial() }),
+  z.object({ type: z.literal("addIndex"), definition: IndexDefinitionSchema }),
+  z.object({ type: z.literal("removeIndex"), name: z.string() }),
+  z.object({ type: z.literal("modifyIndex"), name: z.string(), changes: IndexDefinitionSchema.partial() }),
+  z.object({ type: z.literal("addConstraint"), constraint: z.union([ConstraintSchema, ConstraintGroupSchema]) }),
+  z.object({ type: z.literal("removeConstraint"), name: z.string() }),
+  z.object({ type: z.literal("modifyConstraint"), name: z.string(), changes: ConstraintSchema.partial() }),
+  z.object({ type: z.literal("deprecateField"), name: z.string() })
+]);
+var MigrationSchema = z.object({
+  id: z.string(),
+  schemaVersion: z.string(),
+  changes: z.array(SchemaChangeSchema),
+  description: z.string(),
+  status: z.enum(["pending", "applied", "failed"]),
+  rollback: z.array(SchemaChangeSchema).optional(),
+  transform: z.unknown(),
+  createdAt: z.string(),
+  checksum: z.string().optional()
+});
+function validateMigration(change) {
+  try {
+    MigrationSchema.parse(change);
+    return true;
+  } catch (error) {
+    throw new SchemaValidationError("Invalid migration definition", error);
+  }
+}
+function validateSchemaChange(change) {
+  try {
+    SchemaChangeSchema.parse(change);
+    return true;
+  } catch (error) {
+    throw new SchemaValidationError("Invalid schema definition", error);
+  }
+}
+function validateSchemaDefinition(schema) {
+  try {
+    SchemaDefinitionSchema.parse(schema);
+    return true;
+  } catch (error) {
+    throw new SchemaValidationError("Invalid schema definition", error);
+  }
+}
+var validate = validateSchemaDefinition;
+
+// src/tools/crypto.ts
+var crypto_exports = {};
+__export(crypto_exports, {
+  generateSHA256Hash: () => generateSHA256Hash
+});
+var generateSHA256Hash = async (input) => {
+  if (typeof window !== "undefined" && crypto.subtle) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(input);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  } else {
+    const { createHash } = await import("crypto");
+    return createHash("sha256").update(input).digest("hex");
+  }
+};
+
+// src/tools/version.ts
+var version_exports = {};
+__export(version_exports, {
+  calculateNextVersion: () => calculateNextVersion,
+  compareSemanticVersions: () => compareSemanticVersions,
+  sortSemanticVars: () => sortSemanticVars
+});
+function parseVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) {
+    throw new Error(
+      `Invalid version format: ${version}. Expected format: major.minor.patch`
+    );
+  }
+  return {
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    patch: parseInt(match[3], 10)
+  };
+}
+function determineFieldType(constraint, schema) {
+  if (schema && "field" in constraint && constraint.field) {
+    const fieldDef = schema.fields[constraint.field];
+    if (fieldDef) {
+      return fieldDef.type;
+    }
+  }
+  if ("parameters" in constraint) {
+    const params = constraint.parameters;
+    if (params instanceof RegExp || Array.isArray(params) && typeof params[0] === "string") {
+      return "string";
+    }
+    if (typeof params === "number" || Array.isArray(params) && typeof params[0] === "number") {
+      return "number";
+    }
+    if (typeof params === "boolean") {
+      return "boolean";
+    }
+    if (typeof params === "object" && params !== null) {
+      if ("minItems" in params || "maxItems" in params) {
+        return "array";
+      }
+      if ("schema" in params) {
+        return "object";
+      }
+    }
+  }
+  return void 0;
+}
+function isBreakingFieldChange(changes) {
+  if (changes.required === true) return true;
+  if (changes.type !== void 0) return true;
+  if (changes.itemsType !== void 0) return true;
+  if (changes.nestedSchema !== void 0) return true;
+  if (changes.reference !== void 0) return true;
+  if (changes.unique === true) return true;
+  return false;
+}
+function isBreakingConstraintParameters(oldParams, newParams, fieldType) {
+  switch (fieldType) {
+    case "string":
+      if (oldParams instanceof RegExp && newParams instanceof RegExp) {
+        return oldParams.source !== newParams.source;
+      }
+      if (Array.isArray(oldParams) && Array.isArray(newParams)) {
+        return newParams.length < oldParams.length || !oldParams.every(
+          (val) => newParams.includes(val)
+        );
+      }
+      break;
+    case "number":
+      if (typeof oldParams === "object" && typeof newParams === "object") {
+        if ("precision" in oldParams && "precision" in newParams) {
+          return newParams.precision < oldParams.precision || (newParams.scale ?? 0) < (oldParams.scale ?? 0);
+        }
+      }
+      if (Array.isArray(oldParams) && Array.isArray(newParams)) {
+        return newParams.length < oldParams.length || !oldParams.every(
+          (val) => newParams.includes(val)
+        );
+      }
+      break;
+    case "array":
+      if (typeof oldParams === "object" && typeof newParams === "object" && "minItems" in oldParams && "maxItems" in oldParams && "minItems" in newParams && "maxItems" in newParams) {
+        return newParams.minItems > oldParams.minItems || newParams.maxItems < oldParams.maxItems;
+      }
+      break;
+    case "object":
+      if (typeof oldParams === "object" && typeof newParams === "object" && "schema" in oldParams && "schema" in newParams) {
+        return Object.keys(newParams.schema).length > Object.keys(oldParams.schema).length;
+      }
+      break;
+  }
+  return false;
+}
+function analyzeConstraintGroupChanges(oldGroup, newGroup) {
+  const operatorPriority = {
+    or: 1,
+    xor: 2,
+    and: 3,
+    not: 4,
+    nor: 4
+  };
+  if (newGroup.operator && operatorPriority[newGroup.operator] > operatorPriority[oldGroup.operator]) {
+    return true;
+  }
+  if (newGroup.rules && newGroup.rules.length > oldGroup.rules.length) {
+    return true;
+  }
+  return false;
+}
+function isBreakingConstraintChange(changes, oldConstraint, schema) {
+  if (!oldConstraint) {
+    return true;
+  }
+  if ("rules" in oldConstraint && "rules" in changes) {
+    return analyzeConstraintGroupChanges(
+      oldConstraint,
+      changes
+    );
+  }
+  if ("predicate" in changes && changes.predicate !== void 0) {
+    return true;
+  }
+  if ("parameters" in changes && changes.parameters !== void 0) {
+    const fieldType = determineFieldType(
+      oldConstraint,
+      schema
+    );
+    if (fieldType) {
+      return isBreakingConstraintParameters(
+        oldConstraint.parameters,
+        changes.parameters,
+        fieldType
+      );
+    }
+    return true;
+  }
+  return false;
+}
+function getChangeImpact(change, currentSchema) {
+  switch (change.type) {
+    case "removeField":
+    case "removeIndex":
+      return "major";
+    case "modifyField":
+      if (isBreakingFieldChange(change.changes)) {
+        return "major";
+      }
+      if (change.changes.deprecated) {
+        return "minor";
+      }
+      return "patch";
+    case "modifyIndex":
+      if (change.changes.unique !== void 0 || change.changes.fields !== void 0) {
+        return "major";
+      }
+      return "minor";
+    case "addConstraint":
+      return "major";
+    case "removeConstraint":
+      return "minor";
+    case "modifyConstraint":
+      const oldConstraint = currentSchema?.constraints?.find(
+        (c) => "name" in c && c.name === change.name
+      );
+      if (isBreakingConstraintChange(change.changes, oldConstraint, currentSchema)) {
+        return "major";
+      }
+      return "minor";
+    case "addField":
+    case "addIndex":
+    case "deprecateField":
+      return "minor";
+    default:
+      throw new Error(`Unhandled change type: ${JSON.stringify(change)}`);
+  }
+}
+function validateFieldChanges(changes) {
+  const modifiedFields = /* @__PURE__ */ new Set();
+  const removedFields = /* @__PURE__ */ new Set();
+  const addedFields = /* @__PURE__ */ new Set();
+  const deprecatedFields = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    switch (change.type) {
+      case "addField":
+        if (removedFields.has(change.name)) {
+          throw new Error(
+            `Cannot add previously removed field: ${change.name}`
+          );
+        }
+        if (modifiedFields.has(change.name)) {
+          throw new Error(`Cannot add already modified field: ${change.name}`);
+        }
+        if (deprecatedFields.has(change.name)) {
+          throw new Error(`Cannot add deprecated field: ${change.name}`);
+        }
+        addedFields.add(change.name);
+        break;
+      case "removeField":
+        if (addedFields.has(change.name)) {
+          throw new Error(`Cannot remove newly added field: ${change.name}`);
+        }
+        if (modifiedFields.has(change.name)) {
+          throw new Error(`Cannot remove modified field: ${change.name}`);
+        }
+        if (deprecatedFields.has(change.name)) {
+          throw new Error(
+            `Cannot remove field that is being deprecated: ${change.name}`
+          );
+        }
+        removedFields.add(change.name);
+        break;
+      case "modifyField":
+        if (removedFields.has(change.name)) {
+          throw new Error(`Cannot modify removed field: ${change.name}`);
+        }
+        if (addedFields.has(change.name)) {
+          throw new Error(`Cannot modify newly added field: ${change.name}`);
+        }
+        if (deprecatedFields.has(change.name)) {
+          throw new Error(
+            `Cannot modify field that is being deprecated: ${change.name}`
+          );
+        }
+        modifiedFields.add(change.name);
+        break;
+      case "deprecateField":
+        if (removedFields.has(change.name)) {
+          throw new Error(`Cannot deprecate removed field: ${change.name}`);
+        }
+        if (addedFields.has(change.name)) {
+          throw new Error(`Cannot deprecate newly added field: ${change.name}`);
+        }
+        if (modifiedFields.has(change.name)) {
+          throw new Error(`Cannot deprecate modified field: ${change.name}`);
+        }
+        deprecatedFields.add(change.name);
+        break;
+    }
+  }
+}
+function validateConstraintChanges(changes) {
+  const modifiedConstraints = /* @__PURE__ */ new Set();
+  const removedConstraints = /* @__PURE__ */ new Set();
+  const addedConstraints = /* @__PURE__ */ new Set();
+  for (const change of changes) {
+    switch (change.type) {
+      case "addConstraint":
+        const c = change.constraint;
+        const name = "name" in c ? c.name : c.name;
+        if (removedConstraints.has(name)) {
+          throw new Error(
+            `Cannot add previously removed constraint: ${name}`
+          );
+        }
+        if (modifiedConstraints.has(name)) {
+          throw new Error(`Cannot add already modified constraint: ${name}`);
+        }
+        addedConstraints.add(name);
+        break;
+      case "removeConstraint":
+        if (addedConstraints.has(change.name)) {
+          throw new Error(
+            `Cannot remove newly added constraint: ${change.name}`
+          );
+        }
+        if (modifiedConstraints.has(change.name)) {
+          throw new Error(`Cannot remove modified constraint: ${change.name}`);
+        }
+        removedConstraints.add(change.name);
+        break;
+      case "modifyConstraint":
+        if (removedConstraints.has(change.name)) {
+          throw new Error(`Cannot modify removed constraint: ${change.name}`);
+        }
+        if (addedConstraints.has(change.name)) {
+          throw new Error(
+            `Cannot modify newly added constraint: ${change.name}`
+          );
+        }
+        modifiedConstraints.add(change.name);
+        break;
+    }
+  }
+}
+function calculateNextVersion(currentVersion, changes, currentSchema) {
+  if (changes.length === 0) {
+    throw new Error("No changes provided");
+  }
+  validateFieldChanges(changes);
+  validateConstraintChanges(changes);
+  const version = parseVersion(currentVersion);
+  let highestImpact = "patch";
+  for (const change of changes) {
+    const impact = getChangeImpact(change, currentSchema);
+    if (impact === "major") {
+      highestImpact = "major";
+      break;
+    } else if (impact === "minor" && highestImpact === "patch") {
+      highestImpact = "minor";
+    }
+  }
+  switch (highestImpact) {
+    case "major":
+      return `${version.major + 1}.0.0`;
+    case "minor":
+      return `${version.major}.${version.minor + 1}.0`;
+    case "patch":
+      return `${version.major}.${version.minor}.${version.patch + 1}`;
+  }
+}
+function compareSemanticVersions(a, b) {
+  const parseVersion2 = (version) => version.split(".").map((part) => parseInt(part, 10) || 0);
+  const [aMajor, aMinor, aPatch] = parseVersion2(a);
+  const [bMajor, bMinor, bPatch] = parseVersion2(b);
+  return aMajor - bMajor || aMinor - bMinor || aPatch - bPatch;
+}
+function sortSemanticVars(vars) {
+  return vars.sort(compareSemanticVersions);
+}
+
+// src/lib/migration/index.ts
+var MigrationError = class extends Error {
+  constructor(message, code, migrationId, cause) {
+    super(message);
+    this.code = code;
+    this.migrationId = migrationId;
+    this.cause = cause;
+    this.name = "MigrationError";
+  }
+};
+var MigrationErrorCode = /* @__PURE__ */ ((MigrationErrorCode2) => {
+  MigrationErrorCode2["INVALID_SCHEMA"] = "INVALID_SCHEMA";
+  MigrationErrorCode2["INVALID_MIGRATION"] = "INVALID_MIGRATION";
+  MigrationErrorCode2["CHECKSUM_MISMATCH"] = "CHECKSUM_MISMATCH";
+  MigrationErrorCode2["TIMEOUT"] = "TIMEOUT";
+  MigrationErrorCode2["MEMORY_LIMIT"] = "MEMORY_LIMIT";
+  MigrationErrorCode2["CONCURRENT_OPERATION"] = "CONCURRENT_OPERATION";
+  MigrationErrorCode2["TRANSFORM_ERROR"] = "TRANSFORM_ERROR";
+  MigrationErrorCode2["VERSION_NOT_FOUND"] = "VERSION_NOT_FOUND";
+  MigrationErrorCode2["CIRCULAR_DEPENDENCY"] = "CIRCULAR_DEPENDENCY";
+  MigrationErrorCode2["STREAM_ERROR"] = "STREAM_ERROR";
+  MigrationErrorCode2["ROLLBACK_ERROR"] = "ROLLBACK_ERROR";
+  MigrationErrorCode2["MISSING_TRANSFORM"] = "MISSING_TRANSFORM";
+  return MigrationErrorCode2;
+})(MigrationErrorCode || {});
+var MigrationEngine = class _MigrationEngine {
+  currentSchema;
+  history = [];
+  migrations = [];
+  isProcessing = false;
+  /**
+   * @constructor
+   * @param {SchemaDefinition} currentSchema - The current schema definition
+   * @param {Array<Migration<any>>} [migrations] - Optional array of migrations
+   */
+  constructor(currentSchema, migrations, history) {
+    try {
+      if (!validateSchemaDefinition(currentSchema)) {
+        throw new MigrationError(
+          "Invalid initial schema",
+          "INVALID_SCHEMA" /* INVALID_SCHEMA */
+        );
+      }
+      this.currentSchema = currentSchema;
+      if (migrations) {
+        if (!migrations.every((migration) => validateMigration(migration))) {
+          throw new MigrationError(
+            "Invalid migration configuration",
+            "INVALID_MIGRATION" /* INVALID_MIGRATION */
+          );
+        }
+        this.migrations = migrations.sort(
+          (a, b) => compareSemanticVersions(a.schemaVersion, b.schemaVersion)
+        );
+      }
+      if (history) {
+        this.history = history.sort(
+          (a, b) => compareSemanticVersions(a.version, b.version)
+        );
+      }
+    } catch (error) {
+      if (error instanceof MigrationError) throw error;
+      throw new MigrationError(
+        "Failed to initialize MigrationEngine",
+        "INVALID_SCHEMA" /* INVALID_SCHEMA */,
+        void 0,
+        error
+      );
+    }
+  }
+  /**
+   * Gets the current state of the migration helper
+   * @returns {Object} Current state containing schema, history, and migrations
+   * @example
+   * ```javascript
+   * const state = migrationEngine.data();
+   * // state contains currentSchema, history, and migrations
+   * ```
+   */
+  data() {
+    const result = {
+      schema: this.currentSchema,
+      history: this.history,
+      migrations: this.migrations
+    };
+    return result;
+  }
+  /**
+   * Generates a SHA-256 checksum for a migration
+   * @private
+   * @param {Omit<Migration<any>, "checksum">} migration - The migration object
+   * @returns {Promise<string>} The generated checksum
+   * @throws {MigrationError} If checksum generation fails
+   */
+  async generateChecksum(migration) {
+    try {
+      const payload = JSON.stringify({
+        id: migration.id,
+        schemaVersion: migration.schemaVersion,
+        changes: migration.changes,
+        description: migration.description,
+        rollback: migration.rollback,
+        createdAt: migration.createdAt
+      });
+      return await generateSHA256Hash(payload);
+    } catch (error) {
+      throw new MigrationError(
+        "Checksum generation failed",
+        "CHECKSUM_MISMATCH" /* CHECKSUM_MISMATCH */,
+        migration.id,
+        error
+      );
+    }
+  }
+  /**
+   * Adds a new migration to the engine
+   * @async
+   * @param {Object} opts - Options for the new migration
+   * @param {SchemaChange<any>[]} opts.changes - Array of schema changes
+   * @param {string} opts.description - Description of the migration
+   * @param {SchemaChange<any>[]} [opts.rollback] - Optional rollback changes
+   * @param {DataTransform<any, any>} [opts.transform] - Optional data transform
+   * @throws {MigrationError} If adding the migration fails
+   */
+  async add(opts) {
+    if (this.isProcessing) {
+      throw new MigrationError(
+        "Concurrent operation",
+        "CONCURRENT_OPERATION" /* CONCURRENT_OPERATION */
+      );
+    }
+    if (!opts.changes?.length) {
+      throw new MigrationError(
+        "Migration must include changes",
+        "INVALID_MIGRATION" /* INVALID_MIGRATION */
+      );
+    }
+    try {
+      opts.changes.forEach((change) => validateSchemaChange(change));
+    } catch (error) {
+      throw new MigrationError(
+        "Invalid schema changes",
+        "INVALID_MIGRATION" /* INVALID_MIGRATION */,
+        void 0,
+        error
+      );
+    }
+    const newMigration = {
+      id: Date.now().toString(),
+      schemaVersion: this.currentSchema.version,
+      changes: opts.changes,
+      description: opts.description,
+      status: "pending",
+      rollback: opts.rollback,
+      transform: opts.transform,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      checksum: ""
+    };
+    newMigration.checksum = await this.generateChecksum(newMigration);
+    this.migrations.push(newMigration);
+  }
+  /**
+   * Performs a dry run of the migration
+   * @async
+   * @param {ReadableStream<any>} input - Input data stream
+   * @param {"forward" | "backward"} direction - Direction of migration
+   * @param {version} version - Version to rollback to
+   * @returns {Promise<Object>} Object containing newSchema and dataPreview
+   * @throws {MigrationError} If dry run fails
+   */
+  async dryRun(input, direction, version) {
+    if (this.isProcessing) {
+      throw new MigrationError(
+        "Concurrent operation",
+        "CONCURRENT_OPERATION" /* CONCURRENT_OPERATION */
+      );
+    }
+    try {
+      this.isProcessing = true;
+      const simulatedSchema = { ...this.currentSchema };
+      const relevantMigrations = this.getRelevantMigrations(direction, version);
+      const tempSchema = relevantMigrations.reduce((acc, migration) => {
+        const changes = direction === "forward" ? migration.changes : migration.rollback || [];
+        return this.applySchemaChanges(acc, changes, migration.id);
+      }, simulatedSchema);
+      const previewStream = await _MigrationEngine.processMigrationList(
+        input,
+        direction,
+        relevantMigrations
+      );
+      return { newSchema: tempSchema, dataPreview: previewStream };
+    } catch (error) {
+      if (error instanceof MigrationError) throw error;
+      throw new MigrationError(
+        "Dry run failed",
+        "INVALID_SCHEMA" /* INVALID_SCHEMA */,
+        void 0,
+        error
+      );
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  /**
+   * Gets relevant migrations based on direction
+   * @private
+   * @param {"forward" | "backward"} direction - Direction of migration
+   * @returns {Array<Migration<any>>} Relevant migrations
+   */
+  getRelevantMigrations(direction, version) {
+    return [...this.migrations].filter((m) => {
+      const dir = direction === "forward" ? "pending" : "applied";
+      const vs = version ? compareSemanticVersions(m.schemaVersion, version) >= 0 : true;
+      return m.status === dir && vs;
+    }).sort(
+      (a, b) => direction === "forward" ? a.id.localeCompare(b.id) : b.id.localeCompare(a.id)
+    );
+  }
+  /**
+   * Applies schema changes to a given schema
+   * @private
+   * @param {SchemaDefinition} schema - The schema to modify
+   * @param {SchemaChange<any>[]} changes - Array of schema changes
+   * @param {string} [migrationId] - ID of the migration
+   * @returns {SchemaDefinition} Modified schema
+   * @throws {MigrationError} If applying changes fails
+   */
+  applySchemaChanges(schema, changes, migrationId) {
+    try {
+      const version = calculateNextVersion(schema.version, changes);
+      const patches = changes.map((change) => {
+        try {
+          return schemaChangeToPatch(change, schema);
+        } catch (error) {
+          throw new MigrationError(
+            "Invalid schema change",
+            "INVALID_SCHEMA" /* INVALID_SCHEMA */,
+            migrationId,
+            error
+          );
+        }
+      });
+      return patches.reduce(
+        (acc, patch) => {
+          try {
+            return applyPatch(acc, patch);
+          } catch (error) {
+            throw new MigrationError(
+              "Failed to apply patch",
+              "INVALID_SCHEMA" /* INVALID_SCHEMA */,
+              migrationId,
+              error
+            );
+          }
+        },
+        { ...schema, version }
+      );
+    } catch (error) {
+      if (error instanceof MigrationError) throw error;
+      throw new MigrationError(
+        "Schema update failed",
+        "INVALID_SCHEMA" /* INVALID_SCHEMA */,
+        migrationId,
+        error
+      );
+    }
+  }
+  /**
+   * Prepares the list of pending migrations for application
+   * @async
+   * @returns {Promise<Array<Migration<any>>} List of pending migrations
+   * @throws {MigrationError} If preparation fails
+   */
+  async prepareMigration() {
+    const pendingMigrations = this.migrations.filter(
+      (m) => m.status === "pending"
+    );
+    await this.validateMigrations(pendingMigrations);
+    return pendingMigrations;
+  }
+  /**
+   * Applies pending migrations
+   * @async
+   * @param {ReadableStream<any>} input - Input data stream
+   * @returns {Promise<ReadableStream<any>>} Transformed data stream
+   * @throws {MigrationError} If migration fails
+   */
+  async migrate(input) {
+    if (this.isProcessing) {
+      throw new MigrationError(
+        "Concurrent operation",
+        "CONCURRENT_OPERATION" /* CONCURRENT_OPERATION */
+      );
+    }
+    const pendingMigrations = await this.prepareMigration();
+    try {
+      this.isProcessing = true;
+      this.transformSchema("forward");
+      const result = await _MigrationEngine.processMigrationList(
+        input,
+        "forward",
+        pendingMigrations
+      );
+      this.markMigrationsApplied(pendingMigrations);
+      return result;
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  /**
+   * Validates migrations by checking their checksums
+   * @private
+   * @async
+   * @param {Array<Migration<any>>} migrations - Migrations to validate
+   * @throws {MigrationError} If validation fails
+   */
+  async validateMigrations(migrations) {
+    await Promise.all(
+      migrations.map(async (migration) => {
+        const currentChecksum = await this.generateChecksum(migration);
+        if (migration.checksum !== currentChecksum) {
+          throw new MigrationError(
+            "Checksum mismatch",
+            "CHECKSUM_MISMATCH" /* CHECKSUM_MISMATCH */,
+            migration.id
+          );
+        }
+      })
+    );
+  }
+  /**
+   * Marks migrations as applied
+   * @private
+   * @param {Array<Migration<any>>} migrations - Migrations to mark as applied
+   */
+  markMigrationsApplied(migrations) {
+    this.migrations = this.migrations.map(
+      (m) => migrations.some((mm) => mm.id === m.id) ? { ...m, status: "applied" } : m
+    );
+  }
+  /**
+   * Rolls back the last applied migration
+   * @async
+   * @param {ReadableStream<any>} input - Input data stream
+   * @returns {Promise<ReadableStream<any>>} Transformed data stream
+   */
+  async rollback(input) {
+    if (this.isProcessing) {
+      throw new MigrationError(
+        "Concurrent operation",
+        "CONCURRENT_OPERATION" /* CONCURRENT_OPERATION */
+      );
+    }
+    const lastApplied = this.migrations.filter((m) => m.status === "applied").slice(-1)[0];
+    if (!lastApplied) return input;
+    return this.rollbackToVersion(
+      this.history[this.history.length - 1]?.version || this.currentSchema.version,
+      input
+    );
+  }
+  /**
+   * Rolls back to a specific schema version
+   * @async
+   * @param {string} targetVersion - Target schema version
+   * @param {ReadableStream<any>} input - Input data stream
+   * @returns {Promise<ReadableStream<any>>} Transformed data stream
+   * @throws {Error} If target version is not found
+   */
+  async rollbackToVersion(targetVersion, input) {
+    if (this.isProcessing) {
+      throw new MigrationError(
+        "Concurrent operation",
+        "CONCURRENT_OPERATION" /* CONCURRENT_OPERATION */
+      );
+    }
+    try {
+      const versionIndex = this.history.findIndex(
+        (s) => s.version === targetVersion
+      );
+      if (versionIndex === -1) {
+        throw new Error(`Version ${targetVersion} not found in history`);
+      }
+      const migrations = this.migrations.filter(
+        (m) => m.schemaVersion === targetVersion && m.status === "applied"
+      ).sort((a, b) => b.id.localeCompare(a.id));
+      const stepsBack = this.history.length - versionIndex;
+      if (stepsBack < 0) return input;
+      for (let i = 0; i < stepsBack; i++) {
+        this.transformSchema("backward");
+      }
+      const transformedStream = await _MigrationEngine.processMigrationList(
+        input,
+        "backward",
+        migrations
+      );
+      this.migrations = this.migrations.map((m) => {
+        if (m.schemaVersion === targetVersion && m.status === "applied") {
+          return { ...m, status: "pending" };
+        }
+        return m;
+      });
+      return transformedStream;
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  /**
+   * Processes a list of migrations on a data stream, applying transformations
+   * in the specified direction (forward or backward).
+   *
+   * @static
+   * @async
+   * @param {ReadableStream<any>} input - The input data stream to process
+   * @param {"forward" | "backward"} direction - Direction of migration (either "forward" or "backward")
+   * @param {Array<Migration<any>>} migrations - Array of Migration objects to process
+   * @returns {Promise<ReadableStream<any>>} Transformed data stream
+   * @throws {MigrationError} If any migration processing fails
+   */
+  static async processMigrationList(input, direction, migrations) {
+    const transformEntries = await Promise.all(
+      migrations.map(async (migration) => {
+        try {
+          const transform = await this.resolveTransform(migration, direction);
+          return { migration, transform };
+        } catch (error) {
+          throw new MigrationError(
+            `Failed to resolve transform for migration ${migration.id}`,
+            "TRANSFORM_ERROR" /* TRANSFORM_ERROR */,
+            migration.id,
+            error
+          );
+        }
+      })
+    );
+    const validTransformEntries = transformEntries.filter(
+      (entry) => Boolean(entry.transform)
+    );
+    return validTransformEntries.reduce((stream, { migration, transform }) => {
+      return stream.pipeThrough(
+        new TransformStream({
+          async transform(chunk, controller) {
+            try {
+              const result = await transform(chunk);
+              controller.enqueue(result);
+            } catch (error) {
+              controller.error(
+                new MigrationError(
+                  `Data transformation failed for migration ${migration.id}`,
+                  "TRANSFORM_ERROR" /* TRANSFORM_ERROR */,
+                  migration.id,
+                  error
+                )
+              );
+            }
+          }
+        })
+      );
+    }, input);
+  }
+  /**
+   * Resolves the transform function for a given migration in the specified direction.
+   *
+   * @private
+   * @async
+   * @param {Migration<any>} migration - The migration to resolve the transform for
+   * @param {"forward" | "backward"} direction - Direction of migration
+   * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
+   * @throws {MigrationError} If transform resolution fails
+   */
+  static async resolveTransform(migration, direction) {
+    if (!migration.transform) {
+      return null;
+    }
+    if (typeof migration.transform === "string") {
+      if (migration.transform.startsWith("http://") || migration.transform.startsWith("https://")) {
+        return this.resolveRemoteTransform(migration.transform, direction);
+      }
+      return this.resolveLocalTransform(migration.transform, direction);
+    }
+    return migration.transform[direction];
+  }
+  /**
+   * Resolves a transform function from a remote URL.
+   *
+   * @private
+   * @async
+   * @param {string} url - URL of the transform module
+   * @param {"forward" | "backward"} direction - Direction of migration
+   * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
+   * @throws {MigrationError} If resolution fails
+   */
+  static async resolveRemoteTransform(url, direction) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new MigrationError(
+          `Failed to fetch transform module: ${url}`,
+          "TRANSFORM_ERROR" /* TRANSFORM_ERROR */,
+          void 0
+        );
+      }
+      const moduleText = await response.text();
+      if (typeof window !== "undefined") {
+        const blob = new Blob([moduleText], {
+          type: "application/javascript"
+        });
+        const url2 = URL.createObjectURL(blob);
+        const module = (await import(url2)).default;
+        return module[direction];
+      } else {
+        const { runInNewContext } = await import("vm");
+        const sandbox = { module: { exports: {} }, console };
+        runInNewContext(moduleText, sandbox, url);
+        return sandbox.module.exports[direction];
+      }
+    } catch (error) {
+      throw new MigrationError(
+        `Failed to load remote transform module: ${url}`,
+        "TRANSFORM_ERROR" /* TRANSFORM_ERROR */,
+        void 0,
+        error
+      );
+    }
+  }
+  /**
+   * Resolves a transform function from a local module path.
+   *
+   * @private
+   * @async
+   * @param {string} path - Local module path
+   * @param {"forward" | "backward"} direction - Direction of migration
+   * @returns {Promise<TransformFunction<any, any>>} Resolved transform function
+   * @throws {MigrationError} If resolution fails
+   */
+  static async resolveLocalTransform(path, direction) {
+    try {
+      const module = await import(path);
+      const dataTransform = module.default;
+      return dataTransform[direction];
+    } catch (error) {
+      throw new MigrationError(
+        `Failed to import local transform module: ${path}`,
+        "TRANSFORM_ERROR" /* TRANSFORM_ERROR */,
+        void 0,
+        error
+      );
+    }
+  }
+  /**
+   * Transforms the schema either forward or backward
+   * @private
+   * @param {"forward" | "backward"} direction - Direction of transformation
+   * @throws {Error} If transformation fails
+   */
+  transformSchema(direction) {
+    try {
+      if (direction === "backward") {
+        const schema = this.history.pop();
+        if (!schema) throw new Error("No previous version");
+        this.currentSchema = schema;
+        return;
+      }
+      const changes = this.migrations.filter((m) => m.status === "pending").flatMap((m) => m.changes);
+      if (!changes.length) return;
+      this.history.push(structuredClone(this.currentSchema));
+      this.currentSchema = changes.reduce(
+        (acc, change) => this.applySchemaChanges(acc, [change]),
+        this.currentSchema
+      );
+    } catch (error) {
+      if (error instanceof MigrationError) throw error;
+      throw new MigrationError(
+        "Schema transformation failed",
+        "INVALID_SCHEMA" /* INVALID_SCHEMA */,
+        void 0,
+        error
+      );
+    }
+  }
+};
+
+// src/lib/schema/helpers.ts
+var createSchemaMigrationHelper = (schema) => {
+  const migrate = [];
+  const rollback = [];
+  return {
+    /**
+     * Adds a new field to the schema.
+     * @param {string} fieldName - The name of the field to add.
+     * @param {FieldDefinition<any>} fieldDefinition - The definition of the field to add.
+     */
+    addField: (fieldName, fieldDefinition) => {
+      migrate.push({ type: "addField", name: fieldName, definition: fieldDefinition });
+      rollback.push({ type: "removeField", name: fieldName });
+    },
+    /**
+     * Removes a field from the schema.
+     * @param {string} fieldName - The name of the field to remove.
+     */
+    removeField: (fieldName) => {
+      migrate.push({ type: "removeField", name: fieldName });
+      const originalField = schema.fields[fieldName];
+      if (originalField) {
+        rollback.push({ type: "addField", name: fieldName, definition: originalField });
+      }
+    },
+    /**
+     * Modifies an existing field in the schema.
+     * @param {string} fieldName - The name of the field to modify.
+     * @param {Partial<FieldDefinition<any>>} changes - The changes to apply to the field.
+     */
+    modifyField: (fieldName, changes) => {
+      migrate.push({ type: "modifyField", name: fieldName, changes });
+      const originalField = schema.fields[fieldName];
+      rollback.push({ type: "modifyField", name: fieldName, changes: originalField });
+    },
+    /**
+     * Deprecates a field.
+     * @param {string} fieldName - The name of the field to deprecate.
+     */
+    deprecateField: (fieldName) => {
+      migrate.push({ type: "deprecateField", name: fieldName });
+      rollback.push({
+        type: "modifyField",
+        name: fieldName,
+        changes: { deprecated: false }
+      });
+    },
+    /**
+     * Adds a new index to the schema.
+     * @param {IndexDefinition} indexDefinition - The definition of the index to add.
+     */
+    addIndex: (indexDefinition) => {
+      migrate.push({ type: "addIndex", definition: indexDefinition });
+      rollback.push({ type: "removeIndex", name: indexDefinition.name });
+    },
+    /**
+     * Removes an index from the schema.
+     * @param {string} indexName - The name of the index to remove.
+     */
+    removeIndex: (indexName) => {
+      migrate.push({ type: "removeIndex", name: indexName });
+      const originalIndex = schema.indexes?.find((index) => index.name === indexName);
+      if (originalIndex) {
+        rollback.push({ type: "addIndex", definition: originalIndex });
+      }
+    },
+    /**
+     * Modifies an existing index in the schema.
+     * @param {string} indexName - The name of the index to modify.
+     * @param {Partial<IndexDefinition>} changes - The changes to apply to the index.
+     */
+    modifyIndex: (indexName, changes) => {
+      migrate.push({ type: "modifyIndex", name: indexName, changes });
+      const originalIndex = schema.indexes?.find((index) => index.name === indexName);
+      if (originalIndex) {
+        rollback.push({ type: "modifyIndex", name: indexName, changes: originalIndex });
+      }
+    },
+    /**
+     * Adds a new constraint to the schema.
+     * @param {SchemaConstraint<any>} constraint - The constraint to add.
+     */
+    addConstraint: (constraint) => {
+      migrate.push({ type: "addConstraint", constraint });
+      rollback.push({ type: "removeConstraint", name: constraint.name });
+    },
+    /**
+     * Removes a constraint from the schema.
+     * @param {string} constraintName - The name of the constraint to remove.
+     */
+    removeConstraint: (constraintName) => {
+      migrate.push({ type: "removeConstraint", name: constraintName });
+      const originalConstraint = schema.constraints?.find((c) => "name" in c && c.name === constraintName);
+      if (originalConstraint) {
+        rollback.push({ type: "addConstraint", constraint: originalConstraint });
+      }
+    },
+    /**
+     * Modifies an existing constraint in the schema.
+     * @param {string} constraintName - The name of the constraint to modify.
+     * @param {Partial<SchemaConstraint<any>>} changes - The changes to apply to the constraint.
+     */
+    modifyConstraint: (constraintName, changes) => {
+      migrate.push({ type: "modifyConstraint", name: constraintName, changes });
+      const originalConstraint = schema.constraints?.find((c) => "name" in c && c.name === constraintName);
+      if (originalConstraint) {
+        rollback.push({ type: "modifyConstraint", name: constraintName, changes: originalConstraint });
+      }
+    },
+    /**
+     * Returns the migration changes and their corresponding rollback changes.
+     * @returns {Object} An object containing the migrate and rollback changes.
+     */
+    changes: () => ({
+      migrate,
+      rollback
+    })
+  };
+};
+
+// src/lib/persistence/collection.ts
+var EmphemeralCollection = class {
+  definition;
+  // Stores the schema definition for the collection.
+  collectionEventBus;
+  // Event bus for collection-related events.
+  validator;
+  collectionData = [];
+  // Array to store the collection data.
+  predicateMap;
+  // Map of predicate names to their implementations.
+  match;
+  project;
+  sort;
+  paginate;
+  migrator;
+  /**
+   * @constructor
+   * @param {Record<string, Function>} functionMap Map of function names to their implementations.
+   * @param {Record<string, (params: any) => boolean>} predicateMap Map of predicate names to their implementations.
+   */
+  constructor(schema, functionMap, predicateMap) {
+    this.definition = schema;
+    this.collectionEventBus = createEventBus();
+    this.predicateMap = predicateMap;
+    this.validator = createStandardSchemaValidator(schema, predicateMap)["~standard"];
+    this.match = createMatcher(functionMap);
+    this.project = createProjector(functionMap);
+    this.sort = createSorter();
+    this.paginate = createPaginator();
+    this.migrator = new MigrationEngine(schema);
+  }
+  /**
+   * @method schema
+   * @description Returns the schema definition for the collection.
+   * @returns {SchemaDefinition | null} The schema definition, or null if not set.
+   */
+  schema() {
+    return this.definition;
+  }
+  /**
+   * @method create
+   * @description Creates new data in the collection.
+   * @param {{ data: DataType | DataType[] }} The data to create.
+   * @returns {Promise<DataType | DataType[]>} The created data.
+   */
+  async create({ data }) {
+    const dataArray = Array.isArray(data) ? data : [data];
+    const allIssues = dataArray.reduce(
+      (acc, item) => {
+        const validationResult = this.validate(item);
+        if (validationResult.issues) {
+          acc.push(...validationResult.issues);
+        }
+        return acc;
+      },
+      []
+    );
+    if (allIssues.length > 0) {
+      this.emitCollectionEvent("create:failed", {
+        operation: "create",
+        collection: this.definition?.name || "",
+        input: dataArray,
+        type: "create:failed",
+        timestamp: Date.now(),
+        issues: allIssues
+      });
+      throw new Error(`Invalid data: ${JSON.stringify(allIssues)}`);
+    }
+    this.collectionData.push(...dataArray);
+    this.emitCollectionEvent("create:success", {
+      operation: "create",
+      collection: this.definition?.name || "",
+      input: dataArray,
+      output: dataArray,
+      type: "create:success",
+      timestamp: Date.now()
+    });
+    return data;
+  }
+  /**
+   * @method read
+   * @description Reads data from the collection based on the provided query.
+   * @param {QueryDSL<T>} [query] Optional query to filter the data.
+   * @returns {Promise<T[]>} An array of data matching the query.
+   */
+  async read({
+    query
+  }) {
+    this.emitCollectionEvent("read:start", {
+      operation: "read",
+      collection: this.definition?.name,
+      query,
+      type: "read:start",
+      timestamp: Date.now()
+    });
+    let result = this.collectionData;
+    if (query.filters) {
+      result = result.filter(
+        (item) => this.match.match(item, query.filters)
+      );
+    }
+    if (query.projection) {
+      result = result.map(
+        (item) => this.project.project(item, query.projection)
+      );
+    }
+    if (query.sort) {
+      result = this.sort.sort(result, query.sort);
+    }
+    if (query.pagination) {
+      const paginator = this.paginate.paginate(result, query.pagination);
+      result = (await paginator.next()).value;
+    }
+    this.emitCollectionEvent("read:success", {
+      operation: "read",
+      collection: this.definition?.name,
+      query,
+      output: result,
+      type: "read:success",
+      timestamp: Date.now()
+    });
+    return result;
+  }
+  /**
+   * @method update
+   * @description Updates data in the collection based on the provided query and update data.
+   * @param {{ data?: Partial<T>; patch?: PatchOperation | Array<PatchOperation>; query: QueryFilter }} The update parameters.
+   * @returns {Array<T>} The updated data.
+   */
+  async update({
+    data,
+    patch,
+    query
+  }) {
+    this.emitCollectionEvent("update:start", {
+      operation: "update",
+      collection: this.definition?.name,
+      input: data,
+      query,
+      type: "update:start",
+      timestamp: Date.now()
+    });
+    const results = [];
+    this.collectionData.forEach((i, index) => {
+      if (!this.match.match(i, query)) return;
+      let result = i;
+      if (data) {
+        result = deepMerge(result, data);
+      }
+      if (patch) {
+        const changes = Array.isArray(patch) ? patch : [patch];
+        result = applyPatch(result, changes);
+      }
+      this.collectionData[index] = result;
+      results.push(result);
+    });
+    this.emitCollectionEvent("update:success", {
+      operation: "update",
+      collection: this.definition?.name,
+      input: data,
+      query,
+      output: results,
+      type: "update:success",
+      timestamp: Date.now()
+    });
+    return results;
+  }
+  /**
+   * @method delete
+   * @description Deletes data from the collection based on the provided query.
+   * @param {{ query: QueryFilter<T> }} The query to use for deleting data.
+   * @returns {number} The number of deleted items.
+   */
+  async delete({ query }) {
+    this.emitCollectionEvent("delete:start", {
+      operation: "delete",
+      collection: this.definition?.name,
+      query,
+      type: "delete:start",
+      timestamp: Date.now()
+    });
+    const beforeCount = this.collectionData.length;
+    const remainingItems = this.collectionData.filter(
+      (item) => !this.match.match(item, query)
+    );
+    const deletedCount = beforeCount - remainingItems.length;
+    this.collectionData = remainingItems;
+    this.emitCollectionEvent("delete:success", {
+      operation: "delete",
+      collection: this.definition?.name,
+      query,
+      context: { deletedCount },
+      type: "delete:success",
+      timestamp: Date.now()
+    });
+    return deletedCount;
+  }
+  /**
+   * @method validate
+   * @description Validates data against the collection's schema.
+   * @param {T} data The data to validate.
+   * @returns {{ valid: boolean; issues: StandardSchemaV1.Issue[] | null }} An object containing the validation result.
+   */
+  validate(data) {
+    if (!this.definition) {
+      throw new Error("No schema exists. Call setSchema first.");
+    }
+    if (!this.validator) {
+      this.validator = createStandardSchemaValidator(
+        this.definition,
+        this.predicateMap
+      )["~standard"];
+    }
+    const results = this.validator.validate(
+      data
+    );
+    return { valid: !results.issues, issues: results.issues || null };
+  }
+  /**
+   * @method emitCollectionEvent
+   * @description Emits a collection-related event.
+   * @param {PersistenceEventType} type The type of the event.
+   * @param {PersistenceEvent<SchemaDefinition>} payload The event payload.
+   */
+  emitCollectionEvent(type, payload) {
+    this.collectionEventBus.emit({ name: type, payload });
+  }
+  /**
+   * @method subscribeToCollectionEvents
+   * @description Subscribes to collection-related events.
+   * @param {PersistenceEventType} event The type of the event to subscribe to.
+   * @param {(payload: PersistenceEvent<SchemaDefinition>) => void} callback The callback function.
+   * @returns {() => void} A function to unsubscribe.
+   */
+  subscribe(event, callback) {
+    return this.collectionEventBus.subscribe(event, callback);
+  }
+  async rollback(version, dryRun = true) {
+    this.emitCollectionEvent("rollback:start", {
+      operation: "rollback",
+      collection: this.definition?.name,
+      input: { version },
+      type: "rollback:start",
+      timestamp: Date.now(),
+      context: {
+        dryRun
+      }
+    });
+    if (dryRun) {
+      const input = new ReadableStream({
+        start(controller) {
+          controller.close();
+        }
+      });
+      const result = await this.migrator.dryRun(input, "backward", version);
+      this.emitCollectionEvent("migrate:success", {
+        operation: "rollback",
+        collection: this.definition?.name,
+        input: { version },
+        type: "migrate:success",
+        timestamp: Date.now(),
+        context: {
+          dryRun
+        }
+      });
+      return result;
+    }
+    try {
+      const data = this.collectionData;
+      const input = new ReadableStream({
+        start(controller) {
+          data.forEach((i) => controller.enqueue(i));
+          controller.close();
+        }
+      });
+      const output = Boolean(version) ? await this.migrator.rollbackToVersion(version, input) : await this.migrator.rollback(input);
+      const reader = output.getReader();
+      let value = await reader.read();
+      const result = [];
+      do {
+        if (value.value) {
+          result.push(value.value);
+        }
+        value = await reader.read();
+      } while (!value.done);
+      this.collectionData = result;
+      this.definition = this.migrator.data().schema;
+      this.validator = createStandardSchemaValidator(this.definition, this.predicateMap)["~standard"];
+      this.emitCollectionEvent("rollback:failed", {
+        operation: "rollback",
+        collection: this.definition?.name,
+        input: { version },
+        type: "rollback:failed",
+        timestamp: Date.now(),
+        context: {
+          dryRun
+        }
+      });
+    } catch (error) {
+      this.emitCollectionEvent("migrate:failed", {
+        operation: "rollback",
+        collection: this.definition?.name,
+        input: { version },
+        type: "migrate:failed",
+        timestamp: Date.now(),
+        error,
+        context: {
+          dryRun,
+          error
+        }
+      });
+    }
+  }
+  async migrate(description, cb, dryRun = true) {
+    const helper = createSchemaMigrationHelper(this.definition);
+    const transform = cb(helper);
+    const { migrate, rollback } = helper.changes();
+    this.emitCollectionEvent("migrate:start", {
+      operation: "migrate",
+      collection: this.definition?.name,
+      input: { migrate, rollback },
+      type: "migrate:start",
+      timestamp: Date.now(),
+      context: {
+        dryRun
+      }
+    });
+    await this.migrator.add({
+      description,
+      changes: migrate,
+      rollback,
+      transform
+    });
+    try {
+      if (dryRun) {
+        const input2 = new ReadableStream({
+          start(controller) {
+            controller.close();
+          }
+        });
+        const result2 = await this.migrator.dryRun(input2, "forward");
+        this.emitCollectionEvent("migrate:success", {
+          operation: "migrate",
+          collection: this.definition?.name,
+          input: { migrate, rollback },
+          type: "migrate:success",
+          timestamp: Date.now(),
+          context: {
+            dryRun
+          }
+        });
+        return result2;
+      }
+      const data = this.collectionData;
+      const input = new ReadableStream({
+        start(controller) {
+          data.forEach((i) => controller.enqueue(i));
+          controller.close();
+        }
+      });
+      const output = await this.migrator.migrate(input);
+      const reader = output.getReader();
+      let value = await reader.read();
+      const result = [];
+      do {
+        if (value.value) {
+          result.push(value.value);
+        }
+        value = await reader.read();
+      } while (!value.done);
+      this.collectionData = result;
+      this.definition = this.migrator.data().schema;
+      this.validator = createStandardSchemaValidator(this.definition, this.predicateMap)["~standard"];
+      this.emitCollectionEvent("migrate:success", {
+        operation: "migrate",
+        collection: this.definition?.name,
+        input: { migrate, rollback },
+        type: "migrate:success",
+        timestamp: Date.now(),
+        context: {
+          dryRun
+        }
+      });
+    } catch (error) {
+      this.emitCollectionEvent("migrate:failed", {
+        operation: "migrate",
+        collection: this.definition?.name,
+        input: { migrate, rollback },
+        type: "migrate:failed",
+        timestamp: Date.now(),
+        error,
+        context: {
+          dryRun,
+          error
+        }
+      });
+    }
+  }
+};
+
+// src/lib/persistence/index.ts
+function createEphemeralPersistence(functionMap, predicateMap) {
+  const bus = createEventBus2();
+  const data = /* @__PURE__ */ new Map();
+  function subscribe(event, callback) {
+    return bus.subscribe(event, callback);
+  }
+  function transact(callback) {
+    return callback({
+      createCollection,
+      deleteCollection,
+      collections,
+      schema,
+      collection
+    });
+  }
+  async function createCollection(schema2) {
+    if (data.has(schema2.name)) {
+      bus.emit({
+        name: "collection:create:failed",
+        payload: {
+          operation: "create",
+          collection: schema2.name,
+          input: schema2,
+          type: "collection:create:failed",
+          timestamp: Date.now()
+        }
+      });
+      throw new Error("Collection exists!");
+    }
+    const collection2 = new EmphemeralCollection(
+      schema2,
+      functionMap,
+      predicateMap
+    );
+    data.set(schema2.name, collection2);
+    bus.emit({
+      name: "collection:create:success",
+      payload: {
+        operation: "create",
+        collection: schema2.name,
+        input: schema2,
+        type: "collection:create:success",
+        timestamp: Date.now()
+      }
+    });
+    return collection2;
+  }
+  async function deleteCollection(id) {
+    if (data.has(id)) {
+      data.delete(id);
+      bus.emit({
+        name: "collection:delete:success",
+        payload: {
+          operation: "delete",
+          collection: id,
+          input: id,
+          type: "collection:delete:success",
+          timestamp: Date.now()
+        }
+      });
+    } else {
+      bus.emit({
+        name: "collection:delete:failed",
+        payload: {
+          operation: "delete",
+          collection: id,
+          input: id,
+          type: "collection:delete:failed",
+          timestamp: Date.now()
+        }
+      });
+      throw new Error("Collection not found!");
+    }
+  }
+  async function collections() {
+    return Array.from(data.keys());
+  }
+  async function schema(id) {
+    const collection2 = data.get(id);
+    if (!collection2) throw new Error("Collection not found!");
+    return collection2.schema();
+  }
+  function collection(id) {
+    const coll = data.get(id);
+    if (!coll) throw new Error("Collection not found!");
+    return coll;
+  }
+  return {
+    transact,
+    createCollection,
+    deleteCollection,
+    collections,
+    schema,
+    collection,
+    subscribe
+  };
+}
+
+// src/lib/registry/index.ts
+var registry_exports2 = {};
+__export(registry_exports2, {
+  default: () => createRegistry
+});
+import LightningFS from "@isomorphic-git/lightning-fs";
+import { Buffer as Buffer2 } from "buffer";
+import git from "isomorphic-git";
+import http from "isomorphic-git/http/web";
+
+// src/lib/registry/repository.ts
+async function createGithubRepository({
+  token,
+  repoConfig
+}) {
+  try {
+    const response = await fetch("https://api.github.com/user/repos", {
+      method: "POST",
+      headers: {
+        "X-GitHub-Api-Version": "2022-11-28",
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(repoConfig),
+      redirect: "follow"
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error("Error creating repository:", error);
+    throw error;
+  }
+}
+
+// src/lib/registry/utils.ts
+function serializeGenerator(fn) {
+  const fnStr = fn.toString();
+  const params = fnStr.substring(fnStr.indexOf("(") + 1, fnStr.indexOf(")"));
+  const body = fnStr.substring(fnStr.indexOf("{") + 1, fnStr.lastIndexOf("}")).trim();
+  return JSON.stringify({ params, body });
+}
+function deserializeGenerator(serialized) {
+  const { params, body } = JSON.parse(serialized);
+  const GeneratorFunction = Object.getPrototypeOf(function* () {
+  }).constructor;
+  return new GeneratorFunction(params, body);
+}
+function serializeFunction(fn) {
+  const fnStr = fn.toString();
+  const params = fnStr.substring(fnStr.indexOf("(") + 1, fnStr.indexOf(")"));
+  const body = fnStr.substring(fnStr.indexOf("{") + 1, fnStr.lastIndexOf("}")).trim();
+  return JSON.stringify({ params, body });
+}
+function deserializeFunction(serialized) {
+  const { params, body } = JSON.parse(serialized);
+  return new Function(params, body);
+}
+function authUrl(repoUrl, username, password) {
+  const u = new URL(repoUrl);
+  u.username = username;
+  u.password = password;
+  return u.toString();
+}
+
+// src/lib/registry/index.ts
+window.Buffer = Buffer2;
+async function createRegistry(credentials, dir = "/registry", proxy = "https://cors.isomorphic-git.org") {
+  const fs = new LightningFS(dir);
+  const pfs = fs.promises;
+  const main = "main";
+  async function init() {
+    await pfs.mkdir(dir);
+    await git.init({ fs, dir, defaultBranch: main });
+    await pfs.writeFile(
+      `${dir}/registry.json`,
+      JSON.stringify({
+        schemas: {},
+        created: (/* @__PURE__ */ new Date()).toISOString(),
+        updated: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    await git.add({
+      fs,
+      dir,
+      filepath: `registry.json`
+    });
+    await pfs.writeFile(
+      `${dir}/registry.lock`,
+      JSON.stringify({
+        hashes: [],
+        updated: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+    await git.add({
+      fs,
+      dir,
+      filepath: `registry.lock`
+    });
+    await git.commit({
+      fs,
+      dir,
+      author: { name: "bot", email: "bot@registry.domain" },
+      message: "initial commit"
+    });
+    await createGithubRepository({
+      token: credentials.password,
+      repoConfig: {
+        name: credentials.repository,
+        private: true
+      }
+    });
+    await git.addRemote({
+      fs,
+      dir,
+      remote: "origin",
+      url: `https://github.com/${credentials.username}/${credentials.repository}.git`
+    });
+    await git.push({
+      fs,
+      dir,
+      http,
+      remote: "origin",
+      url: authUrl(
+        `https://github.com/${credentials.username}/${credentials.repository}.git`,
+        credentials.username,
+        credentials.password
+      ),
+      corsProxy: proxy,
+      ref: main,
+      onAuth: () => ({
+        username: credentials.username,
+        password: credentials.password
+      })
+    });
+  }
+  async function clone() {
+    await git.clone({
+      fs,
+      dir,
+      http,
+      corsProxy: proxy,
+      url: authUrl(
+        `https://github.com/${credentials.username}/${credentials.repository}.git`,
+        credentials.username,
+        credentials.password
+      ),
+      onAuth: () => ({
+        username: credentials.username,
+        password: credentials.password
+      }),
+      singleBranch: true,
+      depth: 1
+    });
+  }
+  async function create(schema2) {
+    await git.branch({
+      fs,
+      dir,
+      ref: schema2.name,
+      checkout: true
+    });
+    const dirs = [schema2.name, `${schema2.name}/migrations`];
+    for (const filepath of dirs) {
+      await pfs.mkdir(`${dir}/${filepath}`);
+    }
+    const migrations2 = await Promise.all(
+      (schema2.migrations || []).map(async (migration) => {
+        let content = { ...migration };
+        if (migration.transform && typeof migration.transform !== "string") {
+          content.transform = {
+            forward: serializeFunction(migration.transform.forward),
+            backward: serializeFunction(migration.transform.backward)
+          };
+        }
+        content = JSON.stringify(content);
+        const hash = await generateSHA256Hash(content);
+        return {
+          hash,
+          checksum: migration.checksum,
+          content,
+          id: migration.id
+        };
+      })
+    );
+    await pfs.writeFile(`${dir}/${schema2.name}/migrations/.nomedia`, "");
+    for (const { hash, content } of migrations2) {
+      await pfs.writeFile(
+        `${dir}/${schema2.name}/migrations/${hash}.json`,
+        content
+      );
+    }
+    const schemaContent = JSON.stringify({
+      ...schema2,
+      migrations: [],
+      mock: schema2.mock ? serializeGenerator(schema2.mock) : null
+    });
+    const schemaHash = await generateSHA256Hash(schemaContent);
+    await pfs.writeFile(`${dir}/${schema2.name}/schema.json`, schemaContent);
+    const index = {
+      schema: schema2.name,
+      version: schema2.version,
+      history: [
+        {
+          version: schema2.version,
+          hash: schemaHash,
+          date: (/* @__PURE__ */ new Date()).toISOString(),
+          description: schema2.description || "",
+          migrations: migrations2.map(({ id }) => id),
+          changelog: [],
+          predicates: []
+        }
+      ],
+      migrations: migrations2.reduce(
+        (acc, { hash, checksum, id }) => {
+          acc[id] = { hash, checksum };
+          return acc;
+        },
+        {}
+      )
+    };
+    await pfs.writeFile(
+      `${dir}/${schema2.name}/index.json`,
+      JSON.stringify(index)
+    );
+    await git.add({ fs, dir, filepath: schema2.name });
+    await git.commit({
+      fs,
+      dir,
+      author: { name: "bot", email: "bot@registry.domain" },
+      message: `chore: created schema: ${schema2.name}`
+    });
+    await git.tag({
+      fs,
+      dir,
+      ref: `${schema2.name}-${schema2.version}`
+    });
+    await git.checkout({
+      fs,
+      dir,
+      ref: main
+    });
+    await git.merge({
+      fs,
+      dir,
+      author: { name: "bot", email: "bot@registry.domain" },
+      theirs: `${schema2.name}`,
+      message: `add schema: ${schema2.name}`
+    });
+    await git.checkout({ fs, dir, ref: main });
+    const registry = JSON.parse(
+      (await pfs.readFile(`${dir}/registry.json`)).toString()
+    );
+    registry.updated = (/* @__PURE__ */ new Date()).toISOString();
+    registry.schemas[schema2.name] = {
+      name: schema2.name,
+      version: schema2.version,
+      description: schema2.description || "",
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await pfs.writeFile(`${dir}/registry.json`, JSON.stringify(registry));
+    const files = (await git.listFiles({
+      fs,
+      dir
+    })).filter((i) => i !== "registry.lock");
+    const hashes = await Promise.all(
+      files.map(async (file) => {
+        return [file, await generateSHA256Hash(file)];
+      })
+    );
+    await pfs.writeFile(
+      `${dir}/registry.lock`,
+      JSON.stringify({
+        updated: (/* @__PURE__ */ new Date()).toISOString(),
+        hashes
+      })
+    );
+    await git.add({
+      fs,
+      dir,
+      filepath: `registry.lock`
+    });
+    await git.add({
+      fs,
+      dir,
+      filepath: `registry.json`
+    });
+    await git.commit({
+      fs,
+      dir,
+      author: { name: "bot", email: "bot@registry.domain" },
+      message: `fix: created schema: ${schema2.name}`
+    });
+  }
+  async function update(schema2) {
+    await git.checkout({
+      fs,
+      dir,
+      ref: schema2.name
+    });
+    const migrations2 = await Promise.all(
+      (schema2.migrations || []).map(async (migration) => {
+        let content = { ...migration };
+        if (migration.transform && typeof migration.transform !== "string") {
+          content.transform = {
+            forward: serializeFunction(migration.transform.forward),
+            backward: serializeFunction(migration.transform.backward)
+          };
+        }
+        content = JSON.stringify(content);
+        const hash = await generateSHA256Hash(content);
+        return {
+          hash,
+          checksum: migration.checksum,
+          content,
+          id: migration.id
+        };
+      })
+    );
+    for (const { hash, content } of migrations2) {
+      await pfs.writeFile(
+        `${dir}/${schema2.name}/migrations/${hash}.json`,
+        content
+      );
+    }
+    const schemaContent = JSON.stringify({
+      ...schema2,
+      migrations: [],
+      mock: schema2.mock ? serializeGenerator(schema2.mock) : null
+    });
+    const schemaHash = await generateSHA256Hash(schemaContent);
+    await pfs.writeFile(`${dir}/${schema2.name}/schema.json`, schemaContent);
+    const indexPath = `${dir}/${schema2.name}/index.json`;
+    const existingIndex = JSON.parse(
+      (await pfs.readFile(indexPath)).toString()
+    );
+    const newHistoryEntry = {
+      version: schema2.version,
+      hash: schemaHash,
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      description: schema2.description || "",
+      migrations: migrations2.map(({ id }) => id),
+      changelog: [],
+      predicates: []
+    };
+    existingIndex.history.push(newHistoryEntry);
+    existingIndex.migrations = {
+      ...existingIndex.migrations,
+      ...migrations2.reduce(
+        (acc, { hash, checksum, id }) => {
+          acc[id] = { hash, checksum };
+          return acc;
+        },
+        {}
+      )
+    };
+    await pfs.writeFile(indexPath, JSON.stringify(existingIndex));
+    await git.add({ fs, dir, filepath: schema2.name });
+    await git.commit({
+      fs,
+      dir,
+      author: { name: "bot", email: "bot@registry.domain" },
+      message: `chore: updated schema: ${schema2.name} to version ${schema2.version}`
+    });
+    await git.tag({
+      fs,
+      dir,
+      ref: `${schema2.name}-${schema2.version}`
+    });
+    await git.checkout({
+      fs,
+      dir,
+      ref: main
+    });
+    await git.merge({
+      fs,
+      dir,
+      author: { name: "bot", email: "bot@registry.domain" },
+      theirs: `${schema2.name}`,
+      message: `update schema: ${schema2.name} to version ${schema2.version}`
+    });
+    const registry = JSON.parse(
+      (await pfs.readFile(`${dir}/registry.json`)).toString()
+    );
+    registry.updated = (/* @__PURE__ */ new Date()).toISOString();
+    registry.schemas[schema2.name] = {
+      name: schema2.name,
+      version: schema2.version,
+      description: schema2.description || "",
+      created: registry.schemas[schema2.name]?.created || (/* @__PURE__ */ new Date()).toISOString(),
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await pfs.writeFile(`${dir}/registry.json`, JSON.stringify(registry));
+    const files = (await git.listFiles({
+      fs,
+      dir
+    })).filter((i) => i !== "registry.lock");
+    const hashes = await Promise.all(
+      files.map(async (file) => {
+        return [file, await generateSHA256Hash(file)];
+      })
+    );
+    await pfs.writeFile(
+      `${dir}/registry.lock`,
+      JSON.stringify({
+        updated: (/* @__PURE__ */ new Date()).toISOString(),
+        hashes
+      })
+    );
+    await git.add({
+      fs,
+      dir,
+      filepath: `registry.lock`
+    });
+    await git.add({
+      fs,
+      dir,
+      filepath: `registry.json`
+    });
+    await git.commit({
+      fs,
+      dir,
+      author: { name: "bot", email: "bot@registry.domain" },
+      message: `fix: updated schema: ${schema2.name} to version ${schema2.version}`
+    });
+    await git.checkout({ fs, dir, ref: main });
+  }
+  async function delete_(name) {
+    await git.checkout({
+      fs,
+      dir,
+      ref: main,
+      force: true
+    });
+    await git.deleteBranch({
+      fs,
+      dir,
+      ref: name
+    });
+    const registry = JSON.parse(
+      (await pfs.readFile(`${dir}/registry.json`)).toString()
+    );
+    delete registry.schemas[name];
+    registry.updated = (/* @__PURE__ */ new Date()).toISOString();
+    await pfs.writeFile(`${dir}/registry.json`, JSON.stringify(registry));
+    const files = (await git.listFiles({
+      fs,
+      dir
+    })).filter((i) => i !== "registry.lock");
+    const hashes = await Promise.all(
+      files.map(async (file) => {
+        return [file, await generateSHA256Hash(file)];
+      })
+    );
+    await pfs.writeFile(
+      `${dir}/registry.lock`,
+      JSON.stringify({
+        updated: (/* @__PURE__ */ new Date()).toISOString(),
+        hashes
+      })
+    );
+    await git.add({
+      fs,
+      dir,
+      filepath: `registry.json`
+    });
+    await git.add({
+      fs,
+      dir,
+      filepath: `registry.lock`
+    });
+    await git.commit({
+      fs,
+      dir,
+      author: { name: "bot", email: "bot@registry.domain" },
+      message: `chore: deleted schema: ${name}`
+    });
+  }
+  async function list() {
+    await git.checkout({
+      fs,
+      dir,
+      ref: main,
+      force: true
+    });
+    const registry = JSON.parse(
+      (await pfs.readFile(`${dir}/registry.json`)).toString()
+    );
+    const result = Object.entries(registry.schemas).map(
+      ([name, { version }]) => ({ name, version })
+    );
+    return result;
+  }
+  async function schema(name, version, migrations2 = false) {
+    await git.checkout({
+      fs,
+      dir,
+      ref: main,
+      force: true
+    });
+    const registry = JSON.parse(
+      (await pfs.readFile(`${dir}/registry.json`)).toString()
+    );
+    if (!registry.schemas[name]) {
+      return null;
+    }
+    let ref = name;
+    if (version) {
+      ref = await git.resolveRef({ fs, dir, ref: `${name}-${version}` });
+    }
+    await git.checkout({
+      fs,
+      dir,
+      ref,
+      force: true
+    });
+    const schema2 = JSON.parse(
+      (await pfs.readFile(`${dir}/${name}/schema.json`)).toString()
+    );
+    if (schema2.mock) {
+      schema2.mock = deserializeGenerator(schema2.mock);
+    }
+    if (migrations2) {
+      const migrations3 = await Promise.all(
+        (await pfs.readdir(`${dir}/${name}/migrations`)).filter((i) => i !== ".nomedia").map(
+          async (i) => (await pfs.readFile(`${dir}/${name}/migrations/${i}`)).toString()
+        )
+      );
+      schema2.migrations = migrations3.map((m) => {
+        const migration = JSON.parse(m);
+        migration.transform = {
+          forward: deserializeFunction(migration.transform.forward),
+          backward: deserializeFunction(migration.transform.backward)
+        };
+        return migration;
+      });
+    }
+    await git.checkout({
+      fs,
+      dir,
+      ref: main,
+      force: true
+    });
+    return schema2;
+  }
+  async function stats(schema2) {
+    await git.checkout({
+      fs,
+      dir,
+      ref: main,
+      force: true
+    });
+    if (schema2) {
+      const index = JSON.parse(
+        (await pfs.readFile(`${dir}/${schema2}/index.json`)).toString()
+      );
+      return index;
+    } else {
+      const index = JSON.parse(
+        (await pfs.readFile(`${dir}/registry.json`)).toString()
+      );
+      return index;
+    }
+  }
+  async function sync() {
+    await git.pull({
+      fs,
+      dir,
+      http,
+      remote: "origin",
+      corsProxy: proxy,
+      ref: main,
+      author: { name: "bot", email: "bot@registry.domain" },
+      fastForwardOnly: true,
+      url: authUrl(
+        `https://github.com/${credentials.username}/${credentials.repository}.git`,
+        credentials.username,
+        credentials.password
+      ),
+      onAuth: () => ({
+        username: credentials.username,
+        password: credentials.password
+      })
+    });
+    await git.push({
+      fs,
+      http,
+      dir,
+      corsProxy: proxy,
+      remote: "origin",
+      ref: main,
+      url: authUrl(
+        `https://github.com/${credentials.username}/${credentials.repository}.git`,
+        credentials.username,
+        credentials.password
+      ),
+      onAuth: () => ({
+        username: credentials.username,
+        password: credentials.password
+      })
+    });
+  }
+  async function predicates(name, version) {
+    throw new Error("predicates not implemented");
+  }
+  async function migrations(name, version) {
+    await git.checkout({
+      fs,
+      dir,
+      ref: main,
+      force: true
+    });
+    const registry = JSON.parse(
+      (await pfs.readFile(`${dir}/registry.json`)).toString()
+    );
+    if (!registry.schemas[name]) {
+      return [];
+    }
+    let effectiveVersion = version || registry.schemas[name].version;
+    const index = JSON.parse(
+      (await pfs.readFile(`${dir}/${name}/index.json`)).toString()
+    );
+    const compatibleMigrations = [];
+    for (const migrationId of Object.keys(index.migrations)) {
+      const { hash } = index.migrations[migrationId];
+      const migrationFile = `${dir}/${name}/migrations/${hash}.json`;
+      const migrationContent = JSON.parse(
+        (await pfs.readFile(migrationFile)).toString()
+      );
+      if (compareSemanticVersions(
+        migrationContent.schemaVersion,
+        effectiveVersion
+      ) <= 0) {
+        migrationContent.transform = {
+          forward: deserializeFunction(migrationContent.transform.forward),
+          backward: deserializeFunction(migrationContent.transform.backward)
+        };
+        compatibleMigrations.push(migrationContent);
+      }
+    }
+    return compatibleMigrations.sort(
+      (a, b) => compareSemanticVersions(a.schemaVersion, b.schemaVersion)
+    );
+  }
+  async function history(name) {
+    await git.checkout({
+      fs,
+      dir,
+      ref: main,
+      force: true
+    });
+    const registry = JSON.parse(
+      (await pfs.readFile(`${dir}/registry.json`)).toString()
+    );
+    if (!registry.schemas[name]) {
+      return [];
+    }
+    const index = JSON.parse(
+      (await pfs.readFile(`${dir}/${name}/index.json`)).toString()
+    );
+    const historicalSchemas = [];
+    for (const historyEntry of index.history) {
+      const schemaDefinition = await schema(name, historyEntry.version, true);
+      if (schemaDefinition) {
+        historicalSchemas.push(schemaDefinition);
+      }
+    }
+    return historicalSchemas.sort(
+      (a, b) => compareSemanticVersions(a.version, b.version)
+    );
+  }
+  return {
+    init,
+    clone,
+    create,
+    update,
+    delete: delete_,
+    list,
+    schema,
+    stats,
+    sync,
+    predicates,
+    migrations,
+    history
+  };
+}
+
+// src/lib/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  MigrationSchema: () => MigrationSchema,
+  createSchemaMigrationHelper: () => createSchemaMigrationHelper,
+  validate: () => validate,
+  validateMigration: () => validateMigration,
+  validateSchemaChange: () => validateSchemaChange,
+  validateSchemaDefinition: () => validateSchemaDefinition
+});
+
+// src/tools/typegen.ts
+var typegen_exports = {};
+__export(typegen_exports, {
+  default: () => typegen_default,
+  schemaToTypes: () => schemaToTypes
+});
+function convertFieldTypeToTS(field, parentType, fieldName) {
+  switch (field.type) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      if (field.itemsType) {
+        if (field.itemsType === "object" && field.nestedSchema) {
+          const nestedTypeName = `${parentType}ItemsItem`;
+          return `${nestedTypeName}[]`;
+        }
+        return `${field.itemsType}[]`;
+      }
+      return "any[]";
+    case "object":
+      if (field.nestedSchema) {
+        return `${parentType}${capitalize(fieldName)}`;
+      }
+      return "Record<string, any>";
+    case "dynamic":
+      return "any";
+    default:
+      return "any";
+  }
+}
+function generateNestedTypes(fields, parentName) {
+  let types = "";
+  for (const [fieldName, field] of Object.entries(fields)) {
+    if (field.type === "object" && field.nestedSchema) {
+      const typeName = `${parentName}${capitalize(fieldName)}`;
+      types += `
+export interface ${typeName} {
+${generateTypeProperties(field.nestedSchema, typeName)}
+}`;
+      const nestedTypes = generateNestedTypes(field.nestedSchema, typeName);
+      if (nestedTypes) {
+        types += `
+${nestedTypes}`;
+      }
+    } else if (field.type === "array" && field.itemsType === "object" && field.nestedSchema) {
+      const typeName = `${parentName}ItemsItem`;
+      types += `
+export interface ${typeName} {
+${generateTypeProperties(field.nestedSchema, typeName)}
+}`;
+      const nestedTypes = generateNestedTypes(field.nestedSchema, typeName);
+      if (nestedTypes) {
+        types += `
+${nestedTypes}`;
+      }
+    }
+  }
+  return types;
+}
+function generateTypeProperties(fields, parentType) {
+  return Object.entries(fields).map(([fieldName, field]) => {
+    const lines = [];
+    if (field.description) {
+      lines.push(`    /** ${field.description} */`);
+    }
+    if (field.deprecated) {
+      lines.push("    /** @deprecated */");
+    }
+    const optional = !field.required ? "?" : "";
+    const tsType = convertFieldTypeToTS(field, parentType, fieldName);
+    lines.push(`    ${fieldName}${optional}: ${tsType};`);
+    return lines.join("\n");
+  }).join("\n");
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function schemaToTypes(schema) {
+  const mainTypeName = capitalize(schema.name);
+  let output = `// Generated from schema version ${schema.version}
+`;
+  if (schema.description) {
+    output += `/** ${schema.description} */
+`;
+  }
+  output += `export interface ${mainTypeName} {
+${generateTypeProperties(schema.fields, mainTypeName)}
+}`;
+  const nestedTypes = generateNestedTypes(schema.fields, mainTypeName);
+  if (nestedTypes) {
+    output += `
+${nestedTypes}`;
+  }
+  output += "\n";
+  return output;
+}
+var typegen_default = schemaToTypes;
+export {
+  migrations_exports as MigrationTypes,
+  persistence_exports as PersistenceTypes,
+  registry_exports as RegistryType,
+  schema_definition_exports as SchemaTypes,
+  crypto_exports as crypto,
+  merge_exports as merge,
+  migration_exports as migration,
+  patch_exports as patch,
+  persistence_exports2 as persistence,
+  registry_exports2 as registry,
+  schema_exports as schema,
+  typegen_exports as typegen,
+  validator_exports as validator,
+  version_exports as version
+};