apps 0.0.1-beta.37 → 0.0.1-beta.39

package/js/{chunk-GHDZEEPO.js → chunk-27TDXHRX.js}

@@ -1,6 +1,6 @@
 import {
   makeCache
-} from "./chunk-JU7F4PRK.js";
+} from "./chunk-RIXVGVA6.js";
 import {
   accountSecrets,
   boundFailureMessage,
@@ -11,35 +11,30 @@ import {
   parseSkillLoadFailed,
   readCatalog,
   routerSkills
-} from "./chunk-3LRFKLUX.js";
+} from "./chunk-BO4US6DZ.js";
 import {
   appInvocationFetch
-} from "./chunk-D45FU4TZ.js";
+} from "./chunk-SDHD6J37.js";
 import {
   folderSkillsEffect
-} from "./chunk-BWUHMKHQ.js";
+} from "./chunk-5TJA7364.js";
 import {
   ResponseStatusError,
-  authorDatabase,
   isApp,
-  toEffectApp,
-  unavailableStorage
-} from "./chunk-CAOHGMNW.js";
-import {
-  parseDatabaseSchema
-} from "./chunk-IU7CCCUC.js";
+  toEffectApp
+} from "./chunk-F3TBO2U3.js";
 import {
   declaredOperations,
   fromPromise,
   locate,
   nativeOperation,
   toPromise
-} from "./chunk-7KEKFBV7.js";
+} from "./chunk-7CSHVXVR.js";
 import {
   accountProviderError,
   httpProviderError,
   parseProviderError
-} from "./chunk-ENJCQWVF.js";
+} from "./chunk-E4BWL7KQ.js";
 import {
   AccountCheckResult,
   DeclaredProvider,
@@ -85,18 +80,20 @@ import {
   approvalElicitation,
   defaultWebhookTransportLimits,
   maxInputProblems,
+  migrationsDirectory,
+  reservedTablePrefix,
   workflowDurationMillis
-} from "./chunk-LQBR7AI7.js";
+} from "./chunk-3V575NIW.js";
 import {
   CacheError
-} from "./chunk-BI6R577B.js";
+} from "./chunk-P7MGDPFD.js";
 import {
   AppSkills,
   SkillFile
-} from "./chunk-KEZ4YZSP.js";
+} from "./chunk-MLHNVYHT.js";
 import {
   captureTelemetry
-} from "./chunk-24EIFQYZ.js";
+} from "./chunk-PCV73KVK.js";
 import {
   allowedValues,
   decoderOf,
@@ -107,11 +104,11 @@ import {
   maxAlternativeKeys,
   objectShape,
   unionShape
-} from "./chunk-POOIHRPF.js";
+} from "./chunk-GHXRRFZA.js";
 import {
   JsonObject,
   JsonValue
-} from "./chunk-BI45HZWM.js";
+} from "./chunk-YQ35E7KS.js";
 import {
   Base64_exports,
   Cause_exports,
@@ -124,7 +121,7 @@ import {
   SchemaIssue_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/implementation/elicitation.ts
 var prepareElicitation = (input) => Effect_exports.gen(function* () {
@@ -575,6 +572,333 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
   );
 });
 
+// src/implementation/sql.ts
+var receipts = `${reservedTablePrefix}step_receipts`;
+var migrationsTable = `${reservedTablePrefix}migrations`;
+var legacyRows = `${reservedTablePrefix}legacy_rows`;
+var materialize = (cursor) => {
+  const rows = cursor.toArray();
+  return {
+    columnNames: cursor.columnNames,
+    rowsRead: cursor.rowsRead,
+    rowsWritten: cursor.rowsWritten,
+    toArray: () => [...rows],
+    one: () => {
+      if (rows.length !== 1)
+        throw new Error(`Expected exactly one row, but the statement returned ${rows.length}.`);
+      return rows[0];
+    },
+    [Symbol.iterator]: () => rows[Symbol.iterator]()
+  };
+};
+var isThenable = (value) => (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+var missingDatabase = () => {
+  throw new Error(
+    `This app has no database. Add its first migration, such as ${migrationsDirectory}/0001_create_notes.sql with a CREATE TABLE statement, and deploy again.`
+  );
+};
+var noDatabase = { exec: missingDatabase, transaction: missingDatabase };
+var settings = [
+  "foreign_keys",
+  "defer_foreign_keys",
+  "ignore_check_constraints",
+  "legacy_alter_table",
+  "recursive_triggers",
+  "reverse_unordered_selects"
+];
+var readSettings = (storage) => new Map(
+  settings.map((name) => [name, Number(storage.sql.exec(`PRAGMA ${name}`).toArray()[0]?.[name])])
+);
+var changedSetting = (storage, baseline) => {
+  const current = readSettings(storage);
+  return settings.find((name) => current.get(name) !== baseline.get(name));
+};
+var restoreSettings = (storage, baseline) => {
+  const current = readSettings(storage);
+  for (const [name, value] of baseline)
+    if (current.get(name) !== value) storage.sql.exec(`PRAGMA ${name} = ${value}`);
+  storage.sql.exec("PRAGMA case_sensitive_like = OFF");
+};
+var ReadRolledBack = class extends Error {
+};
+var authorSql = (storage, options) => {
+  let closed = false;
+  const live = () => {
+    if (closed || options.signal.aborted)
+      throw new Error("This call has ended, so its ctx.sql no longer runs statements.");
+  };
+  let open = false;
+  let transactions = 0;
+  const baseline = readSettings(storage);
+  const checkSettings = () => {
+    const changed = changedSetting(storage, baseline);
+    if (changed !== void 0)
+      throw refuse(
+        new Error(
+          `SQLite connection settings belong to Executor, so app code cannot change PRAGMA ${changed}; the statement was rolled back. Migrations may change settings while they run.`
+        )
+      );
+  };
+  const changes = () => Number(storage.sql.exec("SELECT total_changes() AS n").toArray()[0]?.n);
+  let violation;
+  const refuse = (error) => {
+    if (open) violation ??= error;
+    return error;
+  };
+  const run = (query, bindings, mode) => {
+    try {
+      return runStatement(query, bindings, mode);
+    } finally {
+      restoreSettings(storage, baseline);
+    }
+  };
+  const runStatement = (query, bindings, mode) => {
+    live();
+    if (mode === "write") {
+      const statement = () => {
+        const cursor = materialize(storage.sql.exec(query, ...bindings));
+        checkSettings();
+        return cursor;
+      };
+      if (!open) return storage.transactionSync(statement);
+      try {
+        return statement();
+      } catch (error) {
+        refuse(error instanceof Error ? error : new Error(String(error)));
+        throw error;
+      }
+    }
+    if (open) {
+      return runStatement(query, bindings, "write");
+    }
+    const before = changes();
+    let read;
+    let changed = false;
+    try {
+      storage.transactionSync(() => {
+        read = materialize(storage.sql.exec(query, ...bindings));
+        changed = changes() !== before;
+        checkSettings();
+        throw new ReadRolledBack();
+      });
+    } catch (error) {
+      if (!(error instanceof ReadRolledBack)) throw error;
+    }
+    if (changed || read === void 0)
+      throw new Error(
+        options.step !== void 0 ? "A workflow step mutation writes only inside ctx.sql.transaction(...), so a retried step applies its writes once." : "Queries are read-only. Change data from a mutation."
+      );
+    return read;
+  };
+  const reader = {
+    exec: (query, ...bindings) => run(query, bindings, "read")
+  };
+  const transactionHandle = () => {
+    let active = true;
+    const tx = {
+      exec: (query, ...bindings) => {
+        if (!active)
+          throw new Error("This transaction has ended, so its tx no longer runs statements.");
+        return run(query, bindings, "write");
+      }
+    };
+    return {
+      tx,
+      end: () => {
+        active = false;
+      }
+    };
+  };
+  const transaction = (work) => {
+    live();
+    if (open) throw new Error("ctx.sql.transaction(...) cannot be nested.");
+    const step = options.step;
+    if (step !== void 0 && transactions > 0)
+      throw new Error(
+        "A workflow step mutation opens at most one ctx.sql.transaction(...), which records the step's result."
+      );
+    transactions += 1;
+    violation = void 0;
+    const handle = transactionHandle();
+    return storage.transactionSync(() => {
+      open = true;
+      try {
+        const complete = () => {
+          const value = work(handle.tx);
+          if (isThenable(value))
+            throw new Error(
+              "ctx.sql.transaction(...) callbacks are synchronous and cannot await. Call outside services before or after the transaction."
+            );
+          if (violation !== void 0) throw violation;
+          return value;
+        };
+        if (step === void 0) return complete();
+        storage.sql.exec(
+          `CREATE TABLE IF NOT EXISTS ${receipts} (id TEXT PRIMARY KEY, fingerprint TEXT NOT NULL, result TEXT NOT NULL) WITHOUT ROWID`
+        );
+        const saved = storage.sql.exec(`SELECT fingerprint, result FROM ${receipts} WHERE id = ?`, step.key).toArray()[0];
+        if (saved !== void 0) {
+          if (saved.fingerprint !== step.fingerprint)
+            throw new Error("This workflow step already ran with different input.");
+          return JSON.parse(String(saved.result));
+        }
+        const encoded = JSON.stringify(complete() ?? null);
+        storage.sql.exec(
+          `INSERT INTO ${receipts} (id, fingerprint, result) VALUES (?, ?, ?)`,
+          step.key,
+          step.fingerprint,
+          encoded
+        );
+        return JSON.parse(encoded);
+      } finally {
+        open = false;
+        handle.end();
+      }
+    });
+  };
+  const writer = {
+    // A step's writes go through its one transaction, which also records its receipt.
+    exec: (query, ...bindings) => run(query, bindings, options.step ? "read" : "write"),
+    transaction
+  };
+  return {
+    reader,
+    writer,
+    close: () => {
+      closed = true;
+    }
+  };
+};
+var MigrationFileInvalid = class extends Schema_exports.TaggedError()(
+  "MigrationFileInvalid",
+  { path: Schema_exports.String, reason: Schema_exports.String }
+) {
+  get message() {
+    return `${this.path}: ${this.reason}`;
+  }
+};
+var MigrationHistoryChanged = class extends Schema_exports.TaggedError()(
+  "MigrationHistoryChanged",
+  { reason: Schema_exports.String }
+) {
+  get message() {
+    return `${this.reason} Applied migrations cannot change: restore the original file and add a new migration instead. Nothing was applied; the previous deployment is still active.`;
+  }
+};
+var MigrationFailed = class extends Schema_exports.TaggedError()("MigrationFailed", {
+  path: Schema_exports.String,
+  reason: Schema_exports.String
+}) {
+  get message() {
+    return `${this.path} failed: ${this.reason}. No migrations were applied; the previous deployment is still active.`;
+  }
+};
+var migrationName = /^(\d+)_[A-Za-z0-9_-]+\.sql$/;
+var sha256 = (text) => Effect_exports.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))).pipe(
+  Effect_exports.map(
+    (digest) => Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+  )
+);
+var hasMigrations = (files) => files.some(
+  (file) => file.path.startsWith(`${migrationsDirectory}/`) && file.path.endsWith(".sql")
+);
+var migrationsOf = (files) => Effect_exports.gen(function* () {
+  const found = [];
+  for (const file of files) {
+    if (!file.path.startsWith(`${migrationsDirectory}/`) || !file.path.endsWith(".sql")) continue;
+    const name = file.path.slice(migrationsDirectory.length + 1);
+    const match = migrationName.exec(name);
+    if (name.includes("/") || match === null)
+      return yield* new MigrationFileInvalid({
+        path: file.path,
+        reason: "migrations are files directly in migrations/ named like 0001_create_notes.sql: a number that orders them, an underscore, then a name."
+      });
+    const content = file.content.replaceAll("\r\n", "\n");
+    found.push({
+      path: file.path,
+      order: Number(match[1]),
+      content,
+      hash: yield* sha256(content)
+    });
+  }
+  const ordered = [...found].sort((left, right) => left.order - right.order);
+  for (const [index, migration] of ordered.entries()) {
+    const previous = ordered[index - 1];
+    if (previous !== void 0 && previous.order === migration.order)
+      return yield* new MigrationFileInvalid({
+        path: migration.path,
+        reason: `it has the same number as ${previous.path}; give each migration its own number.`
+      });
+  }
+  return ordered;
+});
+var History = Schema_exports.Array(
+  Schema_exports.Struct({ id: Schema_exports.Number, path: Schema_exports.String, hash: Schema_exports.String })
+);
+var migrate = (storage, files) => Effect_exports.gen(function* () {
+  const migrations = yield* migrationsOf(files);
+  const baseline = readSettings(storage);
+  return yield* Effect_exports.sync(
+    () => storage.transactionSync(() => {
+      storage.sql.exec(
+        `CREATE TABLE IF NOT EXISTS ${migrationsTable} (id INTEGER PRIMARY KEY, path TEXT NOT NULL, hash TEXT NOT NULL, applied_at TEXT NOT NULL)`
+      );
+      const stored = storage.sql.exec("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'app_rows'").toArray().length > 0;
+      storage.sql.exec(`DROP VIEW IF EXISTS ${legacyRows}`);
+      storage.sql.exec(
+        `CREATE VIEW ${legacyRows} (table_name, id, body) AS ${stored ? "SELECT table_name, id, body FROM app_rows" : "SELECT '', '', '' WHERE 0"}`
+      );
+      const history = Schema_exports.decodeUnknownSync(History)(
+        storage.sql.exec(`SELECT id, path, hash FROM ${migrationsTable} ORDER BY id`).toArray()
+      );
+      for (const [index, applied] of history.entries()) {
+        const current = migrations[index];
+        if (current === void 0)
+          throw new MigrationHistoryChanged({
+            reason: `${applied.path} was applied to this app's database but is no longer in migrations/.`
+          });
+        if (current.path !== applied.path)
+          throw new MigrationHistoryChanged({
+            reason: `Migration ${index + 1} was applied as ${applied.path}, but the build has ${current.path} in its place.`
+          });
+        if (current.hash !== applied.hash)
+          throw new MigrationHistoryChanged({
+            reason: `${applied.path} changed after it was applied to this app's database.`
+          });
+      }
+      const pending = migrations.slice(history.length);
+      const appliedAt = (/* @__PURE__ */ new Date()).toISOString();
+      for (const [offset, migration] of pending.entries()) {
+        try {
+          storage.sql.exec(migration.content);
+        } catch (error) {
+          throw new MigrationFailed({
+            path: migration.path,
+            reason: error instanceof Error ? error.message : String(error)
+          });
+        }
+        storage.sql.exec(
+          `INSERT INTO ${migrationsTable} (id, path, hash, applied_at) VALUES (?, ?, ?, ?)`,
+          history.length + offset + 1,
+          migration.path,
+          migration.hash,
+          appliedAt
+        );
+      }
+      return pending.map((migration, offset) => ({
+        id: history.length + offset + 1,
+        name: migration.path
+      }));
+    })
+  ).pipe(
+    // Both are thrown inside the transaction so that it rolls back; they are expected failures.
+    Effect_exports.catchDefect(
+      (defect) => Schema_exports.is(MigrationFailed)(defect) || Schema_exports.is(MigrationHistoryChanged)(defect) ? Effect_exports.fail(defect) : Effect_exports.die(defect)
+    ),
+    Effect_exports.ensuring(Effect_exports.sync(() => restoreSettings(storage, baseline)))
+  );
+});
+
 // src/implementation/cache.ts
 var unavailableCache = {
   transport: () => Effect_exports.fail(new CacheError({ reason: "unavailable" })),
@@ -720,7 +1044,7 @@ function providerDeclaration(provider) {
     `Account provider "${provider.name}" has an invalid declaration`
   );
 }
-function requirements(slots, database) {
+function requirements(slots, sql) {
   return Effect_exports.gen(function* () {
     const accounts = /* @__PURE__ */ new Map();
     for (const [slot, selection] of Object.entries(slots)) {
@@ -734,10 +1058,10 @@ function requirements(slots, database) {
     return yield* Schema_exports.decodeUnknownEffect(DeclaredRequirements)({
       accounts: Object.fromEntries(accounts),
       capabilities: { skills: true, toolIndex: true, skillSources: true, scheduledTools: true },
-      ...database === void 0 ? {} : { database }
+      ...sql ? { sql: true } : {}
     }).pipe(
       Effect_exports.mapError(
-        (cause) => declarationInvalid("The app's account or database declarations are invalid", cause)
+        (cause) => declarationInvalid("The app's account declarations are invalid", cause)
       )
     );
   });
@@ -842,28 +1166,51 @@ function dispatch(app, request, context, signal) {
         );
       const native = toEffectApp(app);
       const secrets = accountSecrets(context.accounts);
-      const storageFailure = (error) => Effect_exports.fail(new HostOperationFailed(failureDetail(error, secrets)));
-      const declared = yield* requirements(native.accounts, native.database?.schema);
-      if (request.operation === "requirements") {
-        if (native.database !== void 0)
-          yield* parseDatabaseSchema(native.database.schema).pipe(
-            Effect_exports.catchTag(
-              "AppDatabaseError",
-              (cause) => Effect_exports.fail(
-                declarationInvalid("The app's account or database declarations are invalid", cause)
-              )
-            )
-          );
+      const ownsSql = hasMigrations(context.files ?? []);
+      const declared = yield* requirements(native.accounts, ownsSql);
+      if (request.operation === "requirements")
         return yield* safe2(
           () => Schema_exports.decodeUnknownEffect(JsonValue)(declared),
           new HostDeclarationInvalid()
         );
+      if (request.operation === "migrate") {
+        if (!ownsSql) return yield* new HostOperationNotFound();
+        const storage2 = context.storage;
+        if (storage2 === void 0)
+          return yield* new HostOperationFailed(
+            failureDetail(new Error("This host gave the app no SQL storage."), secrets)
+          );
+        const sources = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(SkillFile))(
+          context.files ?? []
+        ).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+        const applied = yield* migrate(storage2, sources).pipe(
+          Effect_exports.mapError((error) => new HostOperationFailed(failureDetail(error, secrets))),
+          Effect_exports.withSpan("app.sql.migrate")
+        );
+        return yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(JsonValue)(applied),
+          new HostOutputInvalid()
+        );
       }
       const lifetime = yield* Effect_exports.acquireRelease(
         Effect_exports.sync(() => new AbortController()),
         (controller) => Effect_exports.sync(() => controller.abort())
       );
       const invocationSignal = AbortSignal.any([signal, lifetime.signal]);
+      const storage = context.storage;
+      const sqlSession = (step) => !ownsSql ? Effect_exports.succeed({ reader: noDatabase, writer: noDatabase }) : storage === void 0 ? Effect_exports.fail(
+        new HostOperationFailed(
+          failureDetail(new Error("This host gave the app no SQL storage."), secrets)
+        )
+      ) : Effect_exports.acquireRelease(
+        Effect_exports.sync(
+          () => authorSql(storage, {
+            signal: invocationSignal,
+            ...step === void 0 ? {} : { step }
+          })
+        ),
+        (session2) => Effect_exports.sync(session2.close)
+      );
       const deadline = context.deadline === void 0 ? void 0 : yield* safe2(
         () => Schema_exports.decodeUnknownEffect(InvocationDeadline)(context.deadline),
         new HostInputInvalid()
@@ -894,9 +1241,8 @@ function dispatch(app, request, context, signal) {
           deadline
         ).pipe(withinDeadline);
       let running;
-      let transactionOpen = false;
       const delivery = (request2, signal2) => Effect_exports.suspend(
-        () => transactionOpen ? Effect_exports.fail(new ElicitationFailed({ reason: "transaction" })) : running !== void 0 && context.elicitation !== void 0 ? context.elicitation(request2, signal2).pipe(
+        () => running !== void 0 && context.elicitation !== void 0 ? context.elicitation(request2, signal2).pipe(
           Effect_exports.withSpan("app.tool.elicitation"),
           Effect_exports.provideContext(running.context)
         ) : Effect_exports.fail(new ElicitationFailed({ reason: "unavailable" }))
@@ -1075,7 +1421,8 @@ function dispatch(app, request, context, signal) {
         );
       }
       if (request.operation === "webhook-complete" || request.operation === "webhook-validate" || request.operation === "webhooks" || request.operation === "webhook-register" || request.operation === "webhook-handle" || request.operation === "webhook-unregister") {
-        const executeWebhook = (db) => dispatchWebhook(
+        const session2 = yield* sqlSession();
+        return yield* dispatchWebhook(
           definition,
           request,
           {
@@ -1085,23 +1432,10 @@ function dispatch(app, request, context, signal) {
             workflows: workflowControls,
             signal: bound.signal,
             fetch: bound.fetch,
-            ...db === void 0 || native.database === void 0 ? {} : {
-              db: authorDatabase(native.database.tables, db, invocationSignal, true)
-            }
+            sql: session2.writer
           },
           Redacted_exports.value(context.accounts)
         );
-        if (native.database === void 0 || !["webhook-register", "webhook-handle", "webhook-unregister"].includes(request.operation))
-          return yield* executeWebhook();
-        const storage2 = context.storage ?? unavailableStorage;
-        return yield* storage2.mutate(native.database.schema, executeWebhook).pipe(
-          Effect_exports.catchTags({
-            AppDatabaseError: storageFailure,
-            DatabaseLimitExceeded: (error) => Effect_exports.fail(error),
-            AppStorageUnavailable: storageFailure,
-            AppStorageError: storageFailure
-          })
-        );
       }
       const toolName = request.operation === "call" ? request.tool : request.name;
       const location = locate(definition.tools, toolName);
@@ -1161,8 +1495,13 @@ function dispatch(app, request, context, signal) {
           Match_exports.exhaustive
         );
       }
-      const execute = (db) => Effect_exports.gen(function* () {
-        transactionOpen = db !== void 0;
+      const replay = context.replay === void 0 ? void 0 : yield* safe2(
+        () => Schema_exports.decodeUnknownEffect(WorkflowReplay)(context.replay),
+        new HostInputInvalid()
+      );
+      if (replay !== void 0 && kind !== "mutate") return yield* new HostInputInvalid();
+      const session = yield* sqlSession(replay);
+      const execute = () => Effect_exports.gen(function* () {
         const output = yield* Effect_exports.gen(function* () {
           running = yield* captureTelemetry;
           const fetch = yield* appInvocationFetch(fetching.signal);
@@ -1171,14 +1510,7 @@ function dispatch(app, request, context, signal) {
               ...bound,
               fetch,
               workflows: kind === "mutate" ? workflowControls : workflowReads,
-              ...db === void 0 || native.database === void 0 ? {} : {
-                db: authorDatabase(
-                  native.database.tables,
-                  db,
-                  invocationSignal,
-                  kind === "mutate"
-                )
-              }
+              sql: kind === "mutate" ? session.writer : session.reader
             },
             input
           );
@@ -1218,26 +1550,7 @@ function dispatch(app, request, context, signal) {
           new HostOutputInvalid()
         );
       });
-      const replay = context.replay === void 0 ? void 0 : yield* safe2(
-        () => Schema_exports.decodeUnknownEffect(WorkflowReplay)(context.replay),
-        new HostInputInvalid()
-      );
-      if (replay !== void 0 && kind !== "mutate") return yield* new HostInputInvalid();
-      if (native.database === void 0) return yield* withinDeadline(execute());
-      const storage = context.storage ?? unavailableStorage;
-      return yield* storage[kind === "query" ? "read" : "mutate"](
-        native.database.schema,
-        (db) => withinDeadline(
-          replay === void 0 ? execute(db) : db.once(replay.key, replay.fingerprint, () => execute(db))
-        )
-      ).pipe(
-        Effect_exports.catchTags({
-          AppDatabaseError: storageFailure,
-          DatabaseLimitExceeded: (error) => Effect_exports.fail(error),
-          AppStorageUnavailable: storageFailure,
-          AppStorageError: storageFailure
-        })
-      );
+      return yield* withinDeadline(execute());
     })
   );
 }

package/js/{chunk-KOOJUMLR.js → chunk-3MMG2H6M.js}

@@ -160,7 +160,7 @@ import {
   pipeThroughChannel,
   provide,
   provide2,
-  provideContext2 as provideContext,
+  provideContext,
   provideMerge,
   redact,
   remove,
@@ -211,7 +211,7 @@ import {
   withFiber,
   withParentSpan,
   zero2 as zero
-} from "./chunk-IJQ5LE74.js";
+} from "./chunk-MXDKXAY4.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";