@asaidimu/anansi 1.2.1 → 1.2.2

package/index.js

@@ -1,1364 +1,46 @@
-// src/lib/persistence/index.ts
-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 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
-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
-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/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 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
-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 || {});
-
-// 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/registry/index.ts
-import LightningFS from "@isomorphic-git/lightning-fs";
-import { Buffer } from "buffer";
-import git from "isomorphic-git";
-import http from "isomorphic-git/http/web";
-window.Buffer = Buffer;
-
-// src/tools/typegen.ts
-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;
-}
-export {
-  JsonPatchError,
-  MigrationError,
-  MigrationErrorCode,
-  MigrationSchema,
-  applyPatch,
-  calculateNextVersion,
-  compareSemanticVersions,
-  createPatch,
-  createSchemaMigrationHelper,
-  createStandardSchemaValidator,
-  deepMerge,
-  generateSHA256Hash,
-  normalizePath,
-  schemaChangeToPatch,
-  schemaToTypes,
-  sortSemanticVars,
-  validate,
-  validateMigration,
-  validateSchemaChange,
-  validateSchemaDefinition
-};
+import{createEventBus as at}from"@asaidimu/events";import{createEventBus as Ue}from"@asaidimu/events";import{createMatcher as ze,createPaginator as qe,createProjector as Ke,createSorter as Ye}from"@asaidimu/query";var y=class extends Error{constructor(t,n){super(t);this.operation=n;this.name="JsonPatchError"}};function $(e){let r=q(e);return r===""?[]:r.substring(1).split("/").map(K)}function q(e){return e===""||e==="/"?"":e.startsWith("/")?"/"+e.substring(1).split("/").map(C).join("/"):"/"+e.split(".").map(C).join("/")}function C(e){return e.replace(/~/g,"~0").replace(/\//g,"~1")}function K(e){return e.replace(/~1/g,"/").replace(/~0/g,"~")}var w=new Map;function T(e,r){let t=e;for(let n of r){if(t===null||typeof t!="object")throw new y(`Invalid path - parent not found at ${n}`);if(Array.isArray(t)){let a=n==="-"?t.length:parseInt(n);if(isNaN(a)||a<0||a>t.length)throw new y(`Invalid array index: ${n}`);t=t[a]}else{if(!t.hasOwnProperty(n))throw new y(`Property ${n} not found`);t=t[n]}}return t}function E(e,r){let t=w.get(r)||$(r);if(w.set(r,t),t.length===0)return e;let n=T(e,t.slice(0,-1)),a=t[t.length-1];if(Array.isArray(n)){let i=parseInt(a);if(isNaN(i)||i<0||i>=n.length)throw new y(`Invalid array index: ${a}`);return n[i]}return n[a]}function Y(e,r,t){let n=w.get(r)||$(r);w.set(r,n);let a=T(e,n.slice(0,-1)),i=n[n.length-1];return Array.isArray(a)?a.splice(0,a.length,...a.filter(m=>m!==t)):a[i]===t&&delete a[i],e}function v(e,r,t){let n=w.get(r)||$(r);if(w.set(r,n),n.length===0)return t;let a=n.slice(0,-1),i=n[n.length-1],m=T(e,a);if(Array.isArray(m))if(i==="-")m.push(t);else{let c=parseInt(i);if(c<0||c>m.length)throw new y(`Invalid array index: ${i}`);m.splice(c,0,t)}else m[i]=t;return e}function I(e,r){let t=w.get(r)||$(r);if(w.set(r,t),t.length===0)return;let n=T(e,t.slice(0,-1)),a=t[t.length-1];if(Array.isArray(n)){let i=parseInt(a);n.splice(i,1)}else delete n[a];return e}function j(e,r){let t=JSON.parse(JSON.stringify(e));for(let n of r)try{switch(n.op){case"add":t=v(t,n.path,n.value);break;case"remove":t=I(t,n.path);break;case"removeValue":t=Y(t,n.path,n.value);break;case"replace":t=v(I(t,n.path),n.path,n.value);break;case"copy":{let a=E(t,n.from);t=v(t,n.path,JSON.parse(JSON.stringify(a)));break}case"move":{let a=E(t,n.from);t=v(t,n.path,a),t=I(t,n.from);break}case"test":{let a=E(t,n.path);if(JSON.stringify(a)!==JSON.stringify(n.value))throw new y("Test operation failed");break}default:throw new y(`Unsupported operation: ${n.op}`)}}catch(a){throw a instanceof y&&(a.operation=n),a}return t}function $e(e,r){let t=[];return R(e,r,"",t),t}function R(e,r,t,n){if(e!==r){if(typeof e!=typeof r||Array.isArray(e)!==Array.isArray(r)){n.push({op:"replace",path:t,value:r});return}typeof e=="object"&&e!==null?Array.isArray(e)?Q(e,r,t,n):W(e,r,t,n):e!==r&&n.push({op:"replace",path:t,value:r})}}function Q(e,r,t,n){let a=Math.max(e.length,r.length);for(let i=0;i<a;i++){let m=`${t}/${i}`;i>=e.length?n.push({op:"add",path:`${t}/-`,value:r[i]}):i>=r.length?n.push({op:"remove",path:m}):R(e[i],r[i],m,n)}}function W(e,r,t,n){let a=new Set,i=Object.keys(e),m=Object.keys(r);for(let c of i){let d=C(c),s=t?`${t}/${d}`:`/${d}`;r.hasOwnProperty(c)?(R(e[c],r[c],s,n),a.add(c)):n.push({op:"remove",path:s})}for(let c of m)if(!a.has(c)){let d=C(c),s=t?`${t}/${d}`:`/${d}`;n.push({op:"add",path:s,value:r[c]})}}function Z(e,r){let t=[];switch(e.type){case"addField":t.push({op:"add",path:`/fields/${e.name}`,value:e.definition});break;case"removeField":t.push({op:"remove",path:`/fields/${e.name}`});break;case"modifyField":{let n=`/fields/${e.name}`;Object.entries(e.changes).forEach(([a,i])=>{typeof i=="object"&&i!==null&&!Array.isArray(i)?t.push({op:"replace",path:`${n}/${a}`,value:i}):t.push({op:"replace",path:`${n}/${a}`,value:i})});break}case"deprecateField":t.push({op:"add",path:`/fields/${e.name}/deprecated`,value:!0});break;case"addIndex":r.indexes||t.push({op:"add",path:"/indexes",value:[]}),t.push({op:"add",path:"/indexes/-",value:e.definition});break;case"removeIndex":{let n=r.indexes?.findIndex(a=>a.name===e.name);n!==void 0&&n>=0&&t.push({op:"remove",path:`/indexes/${n}`});break}case"modifyIndex":{let n=r.indexes?.findIndex(a=>a.name===e.name);n!==void 0&&n>=0&&Object.entries(e.changes).forEach(([a,i])=>{t.push({op:"replace",path:`/indexes/${n}/${a}`,value:i})});break}case"addConstraint":r.constraints||t.push({op:"add",path:"/constraints",value:[]}),Array.isArray(e.constraint)?e.constraint.forEach(n=>{t.push({op:"add",path:"/constraints/-",value:n})}):t.push({op:"add",path:"/constraints/-",value:e.constraint});break;case"removeConstraint":{let n=r.constraints?.findIndex(a=>Array.isArray(a)?a.some(i=>i.name===e.name):a.name===e.name);n!==void 0&&n>=0&&t.push({op:"remove",path:`/constraints/${n}`});break}case"modifyConstraint":{let n=X(r,e.name);n&&Object.entries(e.changes).forEach(([a,i])=>{t.push({op:"replace",path:`${n}/${a}`,value:i})});break}}return t}function X(e,r){if(!e.constraints)return null;for(let t=0;t<e.constraints.length;t++){let n=e.constraints[t];if(n.name===r)return`/constraints/${t}`;if(V(n)){let a=J(n.rules,r);if(a)return`/constraints/${t}${a}`}}return null}function V(e){return e&&"operator"in e&&"rules"in e}function J(e,r){for(let t=0;t<e.length;t++){let n=e[t];if("name"in n&&n.name===r)return`/rules/${t}`;if(V(n)){let a=J(n.rules,r);if(a)return`/rules/${t}${a}`}}return null}function _(e,r){let t={...e};return k(e)&&k(r)&&Object.keys(r).forEach(n=>{k(r[n])?n in e?t[n]=_(e[n],r[n]):Object.assign(t,{[n]:r[n]}):Object.assign(t,{[n]:r[n]})}),t}function k(e){return e&&typeof e=="object"&&!Array.isArray(e)}function ee(e,r){let t=(s,l,u,p)=>{let f=[];switch(u.type){case"string":typeof s!="string"&&f.push({message:`Expected type string but received ${typeof s}.`,path:p});break;case"number":typeof s!="number"&&f.push({message:`Expected type number but received ${typeof s}.`,path:p});break;case"boolean":typeof s!="boolean"&&f.push({message:`Expected type boolean but received ${typeof s}.`,path:p});break;case"array":Array.isArray(s)?u.itemsType?s.forEach((h,g)=>{f.push(...t(h,`Array: ${l}`,{type:u.itemsType,nestedSchema:u.nestedSchema},[...p,g]))}):f.push({message:`Expected itemsType for array ${l}`,path:p}):f.push({message:`Expected an array but received ${typeof s}.`,path:p});break;case"object":if(typeof s!="object"||s===null)f.push({message:`Expected an object but received ${s===null?"null":typeof s}.`,path:p});else if(u.nestedSchema){let h={name:u.description?`${u.description}-schema`:"nested-schema",version:"1.0",fields:u.nestedSchema};f.push(...d(h,s,p))}break;case"dynamic":break;default:f.push({message:`Unknown field type: ${u.type}`,path:p});break}return f},n=(s,l,u,p)=>{let f=[];return l.constraints&&l.constraints.forEach(h=>{let g=r[h.predicate];g?(h.type==="schema"?g({data:u,arguments:h.parameters}):g({data:u,field:s,arguments:h.parameters}))||f.push({message:`Constraint '${h.name}' failed for field '${s}'.`,path:p}):f.push({message:`Missing predicate for constraint: ${h.name}`,path:p})}),f},a=(s,l,u,p,f)=>[...t(u,s,l,f),...n(s,l,p,f)],i=(s,l,u)=>{if("operator"in s)return m(s.operator,s.rules.map(f=>i(f,l,u)));let p=r[s.predicate];return p?s.type==="schema"?p({data:l,field:s.field,arguments:s.parameters}):p({data:l,field:u,arguments:s.parameters}):!1},m=(s,l)=>{switch(s){case"and":return l.every(Boolean);case"or":return l.some(Boolean);case"not":return l.length===1?!l[0]:!1;case"nor":return!l.some(Boolean);case"xor":return l.filter(Boolean).length===1;default:return console.error(`Unknown logical operator: ${s}`),!1}},c=s=>"operator"in s?`(${s.rules.map(c).join(` ${s.operator} `)})`:s.name,d=(s,l,u=[])=>{let p=[];for(let[f,h]of Object.entries(s.fields))h.required&&l[f]===void 0&&p.push({message:`Field '${f}' is required.`,path:[...u,f]});for(let[f,h]of Object.entries(s.fields)){let g=l[f];g!==void 0&&p.push(...a(f,h,g,l,[...u,f]))}return s.constraints&&s.constraints.forEach(f=>{i(f,l)||p.push({message:`Schema constraint failed: ${c(f)}`,path:u})}),p};return{"~standard":{version:1,vendor:"@asaidimu/anansi",validate:s=>{if(typeof s!="object"||s===null)return{issues:[{message:"Value must be a non-null object",path:[]}]};let l=d(e,s);return l.length===0?{value:s}:{issues:l}}}}}import{z as o}from"zod";var S=class extends Error{constructor(t,n){super(t);this.errors=n;this.name="SchemaValidationError"}};var H=o.enum(["and","or","not","nor","xor"]),L=o.enum(["string","number","boolean","array","object","dynamic"]),te=o.enum(["normal","unique","btree","hash","spatial","fulltext","gi","expression","composite"]),ne=o.custom(()=>!0),b=o.object({type:o.string().optional(),name:o.string(),predicate:o.string().optional(),parameters:ne.optional(),description:o.string().optional(),field:o.string().optional(),errorMessage:o.string().optional()}),M=o.object({operator:H,rules:o.array(o.union([b,o.lazy(()=>M)]))}),x=o.object({type:L,required:o.boolean().optional(),constraints:o.array(b).optional(),default:o.any().optional(),itemsType:L.optional(),nestedSchema:o.record(o.lazy(()=>x)).optional(),deprecated:o.boolean().optional(),reference:o.object({schema:o.string(),field:o.string()}).optional(),description:o.string().optional(),unique:o.boolean().optional()}),G=o.object({operator:H,field:o.string(),value:o.any().optional(),conditions:o.array(o.lazy(()=>G)).optional()}),D=o.object({fields:o.array(o.string()),type:te,unique:o.boolean().optional(),partial:G.optional(),description:o.string().optional(),order:o.enum(["asc","desc"]).optional(),name:o.string().optional()}),re=o.array(o.union([b,M])),ae=o.object({name:o.string(),version:o.string(),description:o.string().optional(),fields:o.record(x),indexes:o.array(D).optional(),constraints:re.optional(),metadata:o.record(o.any()).optional(),dependencies:o.array(o.string()).optional(),migrations:o.array(o.any()).optional()}),O=o.union([o.object({type:o.literal("addField"),name:o.string(),definition:x}),o.object({type:o.literal("removeField"),name:o.string()}),o.object({type:o.literal("modifyField"),name:o.string(),changes:x.partial()}),o.object({type:o.literal("addIndex"),definition:D}),o.object({type:o.literal("removeIndex"),name:o.string()}),o.object({type:o.literal("modifyIndex"),name:o.string(),changes:D.partial()}),o.object({type:o.literal("addConstraint"),constraint:o.union([b,M])}),o.object({type:o.literal("removeConstraint"),name:o.string()}),o.object({type:o.literal("modifyConstraint"),name:o.string(),changes:b.partial()}),o.object({type:o.literal("deprecateField"),name:o.string()})]),ie=o.object({id:o.string(),schemaVersion:o.string(),changes:o.array(O),description:o.string(),status:o.enum(["pending","applied","failed"]),rollback:o.array(O).optional(),transform:o.unknown(),createdAt:o.string(),checksum:o.string().optional()});function oe(e){try{return ie.parse(e),!0}catch(r){throw new S("Invalid migration definition",r)}}function se(e){try{return O.parse(e),!0}catch(r){throw new S("Invalid schema definition",r)}}function U(e){try{return ae.parse(e),!0}catch(r){throw new S("Invalid schema definition",r)}}var Oe=U;var B=async e=>{if(typeof window<"u"&&crypto.subtle){let t=new TextEncoder().encode(e),n=await crypto.subtle.digest("SHA-256",t);return Array.from(new Uint8Array(n)).map(i=>i.toString(16).padStart(2,"0")).join("")}else{let{createHash:r}=await import("crypto");return r("sha256").update(e).digest("hex")}};function ce(e){let r=e.match(/^(\d+)\.(\d+)\.(\d+)$/);if(!r)throw new Error(`Invalid version format: ${e}. Expected format: major.minor.patch`);return{major:parseInt(r[1],10),minor:parseInt(r[2],10),patch:parseInt(r[3],10)}}function pe(e,r){if(r&&"field"in e&&e.field){let t=r.fields[e.field];if(t)return t.type}if("parameters"in e){let t=e.parameters;if(t instanceof RegExp||Array.isArray(t)&&typeof t[0]=="string")return"string";if(typeof t=="number"||Array.isArray(t)&&typeof t[0]=="number")return"number";if(typeof t=="boolean")return"boolean";if(typeof t=="object"&&t!==null){if("minItems"in t||"maxItems"in t)return"array";if("schema"in t)return"object"}}}function me(e){return e.required===!0||e.type!==void 0||e.itemsType!==void 0||e.nestedSchema!==void 0||e.reference!==void 0||e.unique===!0}function de(e,r,t){switch(t){case"string":if(e instanceof RegExp&&r instanceof RegExp)return e.source!==r.source;if(Array.isArray(e)&&Array.isArray(r))return r.length<e.length||!e.every(n=>r.includes(n));break;case"number":if(typeof e=="object"&&typeof r=="object"&&"precision"in e&&"precision"in r)return r.precision<e.precision||(r.scale??0)<(e.scale??0);if(Array.isArray(e)&&Array.isArray(r))return r.length<e.length||!e.every(n=>r.includes(n));break;case"array":if(typeof e=="object"&&typeof r=="object"&&"minItems"in e&&"maxItems"in e&&"minItems"in r&&"maxItems"in r)return r.minItems>e.minItems||r.maxItems<e.maxItems;break;case"object":if(typeof e=="object"&&typeof r=="object"&&"schema"in e&&"schema"in r)return Object.keys(r.schema).length>Object.keys(e.schema).length;break}return!1}function le(e,r){let t={or:1,xor:2,and:3,not:4,nor:4};return!!(r.operator&&t[r.operator]>t[e.operator]||r.rules&&r.rules.length>e.rules.length)}function fe(e,r,t){if(!r)return!0;if("rules"in r&&"rules"in e)return le(r,e);if("predicate"in e&&e.predicate!==void 0)return!0;if("parameters"in e&&e.parameters!==void 0){let n=pe(r,t);return n?de(r.parameters,e.parameters,n):!0}return!1}function ue(e,r){switch(e.type){case"removeField":case"removeIndex":return"major";case"modifyField":return me(e.changes)?"major":e.changes.deprecated?"minor":"patch";case"modifyIndex":return e.changes.unique!==void 0||e.changes.fields!==void 0?"major":"minor";case"addConstraint":return"major";case"removeConstraint":return"minor";case"modifyConstraint":let t=r?.constraints?.find(n=>"name"in n&&n.name===e.name);return fe(e.changes,t,r)?"major":"minor";case"addField":case"addIndex":case"deprecateField":return"minor";default:throw new Error(`Unhandled change type: ${JSON.stringify(e)}`)}}function he(e){let r=new Set,t=new Set,n=new Set,a=new Set;for(let i of e)switch(i.type){case"addField":if(t.has(i.name))throw new Error(`Cannot add previously removed field: ${i.name}`);if(r.has(i.name))throw new Error(`Cannot add already modified field: ${i.name}`);if(a.has(i.name))throw new Error(`Cannot add deprecated field: ${i.name}`);n.add(i.name);break;case"removeField":if(n.has(i.name))throw new Error(`Cannot remove newly added field: ${i.name}`);if(r.has(i.name))throw new Error(`Cannot remove modified field: ${i.name}`);if(a.has(i.name))throw new Error(`Cannot remove field that is being deprecated: ${i.name}`);t.add(i.name);break;case"modifyField":if(t.has(i.name))throw new Error(`Cannot modify removed field: ${i.name}`);if(n.has(i.name))throw new Error(`Cannot modify newly added field: ${i.name}`);if(a.has(i.name))throw new Error(`Cannot modify field that is being deprecated: ${i.name}`);r.add(i.name);break;case"deprecateField":if(t.has(i.name))throw new Error(`Cannot deprecate removed field: ${i.name}`);if(n.has(i.name))throw new Error(`Cannot deprecate newly added field: ${i.name}`);if(r.has(i.name))throw new Error(`Cannot deprecate modified field: ${i.name}`);a.add(i.name);break}}function ye(e){let r=new Set,t=new Set,n=new Set;for(let a of e)switch(a.type){case"addConstraint":let i=a.constraint,m=("name"in i,i.name);if(t.has(m))throw new Error(`Cannot add previously removed constraint: ${m}`);if(r.has(m))throw new Error(`Cannot add already modified constraint: ${m}`);n.add(m);break;case"removeConstraint":if(n.has(a.name))throw new Error(`Cannot remove newly added constraint: ${a.name}`);if(r.has(a.name))throw new Error(`Cannot remove modified constraint: ${a.name}`);t.add(a.name);break;case"modifyConstraint":if(t.has(a.name))throw new Error(`Cannot modify removed constraint: ${a.name}`);if(n.has(a.name))throw new Error(`Cannot modify newly added constraint: ${a.name}`);r.add(a.name);break}}function ge(e,r,t){if(r.length===0)throw new Error("No changes provided");he(r),ye(r);let n=ce(e),a="patch";for(let i of r){let m=ue(i,t);if(m==="major"){a="major";break}else m==="minor"&&a==="patch"&&(a="minor")}switch(a){case"major":return`${n.major+1}.0.0`;case"minor":return`${n.major}.${n.minor+1}.0`;case"patch":return`${n.major}.${n.minor}.${n.patch+1}`}}function P(e,r){let t=s=>s.split(".").map(l=>parseInt(l,10)||0),[n,a,i]=t(e),[m,c,d]=t(r);return n-m||a-c||i-d}function Fe(e){return e.sort(P)}var z=class extends Error{constructor(t,n,a,i){super(t);this.code=n;this.migrationId=a;this.cause=i;this.name="MigrationError"}},we=(p=>(p.INVALID_SCHEMA="INVALID_SCHEMA",p.INVALID_MIGRATION="INVALID_MIGRATION",p.CHECKSUM_MISMATCH="CHECKSUM_MISMATCH",p.TIMEOUT="TIMEOUT",p.MEMORY_LIMIT="MEMORY_LIMIT",p.CONCURRENT_OPERATION="CONCURRENT_OPERATION",p.TRANSFORM_ERROR="TRANSFORM_ERROR",p.VERSION_NOT_FOUND="VERSION_NOT_FOUND",p.CIRCULAR_DEPENDENCY="CIRCULAR_DEPENDENCY",p.STREAM_ERROR="STREAM_ERROR",p.ROLLBACK_ERROR="ROLLBACK_ERROR",p.MISSING_TRANSFORM="MISSING_TRANSFORM",p))(we||{});var Se=e=>{let r=[],t=[];return{addField:(n,a)=>{r.push({type:"addField",name:n,definition:a}),t.push({type:"removeField",name:n})},removeField:n=>{r.push({type:"removeField",name:n});let a=e.fields[n];a&&t.push({type:"addField",name:n,definition:a})},modifyField:(n,a)=>{r.push({type:"modifyField",name:n,changes:a});let i=e.fields[n];t.push({type:"modifyField",name:n,changes:i})},deprecateField:n=>{r.push({type:"deprecateField",name:n}),t.push({type:"modifyField",name:n,changes:{deprecated:!1}})},addIndex:n=>{r.push({type:"addIndex",definition:n}),t.push({type:"removeIndex",name:n.name})},removeIndex:n=>{r.push({type:"removeIndex",name:n});let a=e.indexes?.find(i=>i.name===n);a&&t.push({type:"addIndex",definition:a})},modifyIndex:(n,a)=>{r.push({type:"modifyIndex",name:n,changes:a});let i=e.indexes?.find(m=>m.name===n);i&&t.push({type:"modifyIndex",name:n,changes:i})},addConstraint:n=>{r.push({type:"addConstraint",constraint:n}),t.push({type:"removeConstraint",name:n.name})},removeConstraint:n=>{r.push({type:"removeConstraint",name:n});let a=e.constraints?.find(i=>"name"in i&&i.name===n);a&&t.push({type:"addConstraint",constraint:a})},modifyConstraint:(n,a)=>{r.push({type:"modifyConstraint",name:n,changes:a});let i=e.constraints?.find(m=>"name"in m&&m.name===n);i&&t.push({type:"modifyConstraint",name:n,changes:i})},changes:()=>({migrate:r,rollback:t})}};import wt from"@isomorphic-git/lightning-fs";import{Buffer as be}from"buffer";import vt from"isomorphic-git";import $t from"isomorphic-git/http/web";window.Buffer=be;function ve(e,r,t){switch(e.type){case"string":return"string";case"number":return"number";case"boolean":return"boolean";case"array":return e.itemsType?e.itemsType==="object"&&e.nestedSchema?`${`${r}ItemsItem`}[]`:`${e.itemsType}[]`:"any[]";case"object":return e.nestedSchema?`${r}${N(t)}`:"Record<string, any>";case"dynamic":return"any";default:return"any"}}function F(e,r){let t="";for(let[n,a]of Object.entries(e))if(a.type==="object"&&a.nestedSchema){let i=`${r}${N(n)}`;t+=`
+export interface ${i} {
+${A(a.nestedSchema,i)}
+}`;let m=F(a.nestedSchema,i);m&&(t+=`
+${m}`)}else if(a.type==="array"&&a.itemsType==="object"&&a.nestedSchema){let i=`${r}ItemsItem`;t+=`
+export interface ${i} {
+${A(a.nestedSchema,i)}
+}`;let m=F(a.nestedSchema,i);m&&(t+=`
+${m}`)}return t}function A(e,r){return Object.entries(e).map(([t,n])=>{let a=[];n.description&&a.push(`    /** ${n.description} */`),n.deprecated&&a.push("    /** @deprecated */");let i=n.required?"":"?",m=ve(n,r,t);return a.push(`    ${t}${i}: ${m};`),a.join(`
+`)}).join(`
+`)}function N(e){return e.charAt(0).toUpperCase()+e.slice(1)}function Dt(e){let r=N(e.name),t=`// Generated from schema version ${e.version}
+`;e.description&&(t+=`/** ${e.description} */
+`),t+=`export interface ${r} {
+${A(e.fields,r)}
+}`;let n=F(e.fields,r);return n&&(t+=`
+${n}`),t+=`
+`,t}function Mt(e,r){let t=[],n=c=>c===void 0?"`None`":`\`${JSON.stringify(c,null,2)}\``,a=(c=[])=>c.map(d=>`- **${d.name}**: ${d.description||""}
+  - Parameters: ${JSON.stringify(d.parameters)}
+  - Error: ${d.errorMessage||"None"}`).join(`
+`),i=c=>{let d=`**${c.field}** ${c.operator}`;return c.value!==void 0&&(d+=` ${JSON.stringify(c.value)}`),c.conditions&&(d+=` [
+${c.conditions.map(s=>`    ${i(s)}`).join(`
+`)}
+  ]`),d},m=(c,d=1)=>{let s="#".repeat(d+2);return Object.entries(c).map(([l,u])=>{let p=`${s} ${l} (${u.type})
+
+`;return p+=`**Required:** ${u.required?"Yes":"No"}
+
+`,u.description&&(p+=`**Description:** ${u.description}
+
+`),u.itemsType&&(p+=`**Item Type:** ${u.itemsType}
+
+`),u.nestedSchema&&(p+=m(u.nestedSchema,d+1)),p}).join(`
+`)};t.push(`# ${e.name} Schema (Version ${e.version})`),e.description&&t.push(`
+${e.description}
+`),t.push("## Metadata"),t.push(`- **Dependencies:** ${e.dependencies?.join(", ")||"None"}`),t.push(`- **Created:** ${new Date().toISOString()}
+`),t.push(`## Fields
+`),t.push("| Name | Type | Required | Default | Description | Deprecated | Unique | Constraints |"),t.push("|------|------|----------|---------|-------------|------------|--------|-------------|");for(let[c,d]of Object.entries(e.fields))t.push([c,d.type,d.required?"Yes":"No",n(d.default),d.description?.replace(/\n/g," ")||"",d.deprecated?"Yes":"No",d.unique?"Yes":"No",d.constraints?.length||0].join("|"));Object.entries(e.fields).forEach(([c,d])=>{d.nestedSchema&&(t.push(`
+### Nested Schema: ${c}
+`),t.push(m(d.nestedSchema)))}),t.push(`
+## Indexes
+`),t.push("| Name | Type | Fields | Unique | Order | Partial Condition | Description |"),t.push("|------|------|--------|--------|-------|-------------------|-------------|");for(let c of e.indexes||[])t.push([c.name,c.type,c.fields.join(", "),c.unique?"Yes":"No",c.order||"asc",c.partial?i(c.partial):"None",c.description||""].join("|"));t.push(`
+## Constraints
+`),e.constraints&&t.push("### Schema-level Constraints"),t.push(`
+## Migrations
+`),t.push("| ID | Description | Status | Changes |"),t.push("|----|-------------|--------|---------|");for(let c of e.migrations||[])t.push([c.id,c.description,c.status,c.changes.length].join("|"));if(e.mock&&r?.faker)try{let c=e.mock(r.faker).next().value;t.push("\n## Example Data\n```json\n"+JSON.stringify(c,null,2)+"\n```")}catch{t.push(`
+<!-- Error generating mock data -->`)}return t.join(`
+`)}export{y as JsonPatchError,z as MigrationError,we as MigrationErrorCode,ie as MigrationSchema,j as applyPatch,ge as calculateNextVersion,P as compareSemanticVersions,$e as createPatch,Se as createSchemaMigrationHelper,ee as createStandardSchemaValidator,_ as deepMerge,Mt as docgen,B as generateSHA256Hash,q as normalizePath,Z as schemaChangeToPatch,Dt as schemaToTypes,Fe as sortSemanticVars,Oe as validate,oe as validateMigration,se as validateSchemaChange,U as validateSchemaDefinition};