@asaidimu/anansi 1.1.0 → 1.2.0

package/index.js

@@ -1,26 +1,4 @@
-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
@@ -33,14 +11,6 @@ import {
 } 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);
@@ -446,10 +416,6 @@ function searchRules(rules, name) {
 }
 
 // src/tools/merge.ts
-var merge_exports = {};
-__export(merge_exports, {
-  deepMerge: () => deepMerge
-});
 function deepMerge(target, update) {
   const output = { ...target };
   if (isObject(target) && isObject(update)) {
@@ -475,10 +441,6 @@ function isObject(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 = [];
@@ -680,14 +642,6 @@ function createStandardSchemaValidator(schema, constraintsMap) {
   };
 }
 
-// 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";
 
@@ -809,10 +763,6 @@ function validateSchemaDefinition(schema) {
 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();
@@ -827,12 +777,6 @@ var generateSHA256Hash = async (input) => {
 };
 
 // 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) {
@@ -1173,561 +1117,6 @@ var MigrationErrorCode = /* @__PURE__ */ ((MigrationErrorCode2) => {
   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) => {
@@ -1849,1214 +1238,14 @@ var createSchemaMigrationHelper = (schema) => {
   };
 };
 
-// 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 { Buffer } 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
-});
+window.Buffer = Buffer;
 
 // 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":
@@ -3151,20 +1340,25 @@ ${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
+  JsonPatchError,
+  MigrationError,
+  MigrationErrorCode,
+  MigrationSchema,
+  applyPatch,
+  calculateNextVersion,
+  compareSemanticVersions,
+  createPatch,
+  createSchemaMigrationHelper,
+  createStandardSchemaValidator,
+  deepMerge,
+  generateSHA256Hash,
+  normalizePath,
+  schemaChangeToPatch,
+  schemaToTypes,
+  sortSemanticVars,
+  validate,
+  validateMigration,
+  validateSchemaChange,
+  validateSchemaDefinition
 };