apps 0.0.1-beta.8 → 0.0.1-beta.81

package/js/chunk-ZQINWV4W.js

@@ -1,630 +0,0 @@
-import {
-  AppDatabaseError,
-  DatabaseFieldReserved,
-  DatabaseLimitExceeded,
-  DatabaseLimits,
-  DatabaseOperation,
-  DatabaseSchema,
-  PaginationResult,
-  RangeClause,
-  Row,
-  RowMetadata,
-  defaultDatabaseLimits,
-  defaultDatabaseRuntimeLimits,
-  reservedFieldNames
-} from "./chunk-N7YDVXYJ.js";
-import {
-  Cause_exports,
-  Clock_exports,
-  Effect_exports,
-  Encoding_exports,
-  Schema_exports,
-  Semaphore_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// ../app-data/src/implementation/schema.ts
-var metadata = new Set(reservedFieldNames);
-var reserved = (name) => metadata.has(name);
-var indexesFor = (table) => [{ name: "by_creation", fields: [] }, ...table.indexes].map((index) => ({
-  name: index.name,
-  fields: [
-    ...index.fields,
-    ...["createdAt", "id"].filter((field) => !index.fields.includes(field))
-  ]
-}));
-var fieldFor = (table, name) => metadata.has(name) ? { kind: "string" } : Object.hasOwn(table.fields, name) ? table.fields[name] : void 0;
-var validScalar = (field, value) => field.kind === "number" ? typeof value === "number" && Number.isFinite(value) : field.kind === "boolean" ? typeof value === "boolean" : typeof value === "string" && ![...value].some((character) => {
-  const point = character.codePointAt(0);
-  return point !== void 0 && point >= 55296 && point <= 57343;
-});
-var parseDatabaseSchema = (input) => Schema_exports.decodeUnknownEffect(DatabaseSchema)(input).pipe(
-  Effect_exports.mapError(() => new AppDatabaseError({ reason: "schema" })),
-  Effect_exports.flatMap(
-    (schema) => Effect_exports.gen(function* () {
-      for (const [name, table] of Object.entries(schema)) {
-        const field = Object.keys(table.fields).find(reserved);
-        if (field !== void 0) return yield* new DatabaseFieldReserved({ table: name, field });
-        if (new Set(table.indexes.map((index) => index.name)).size !== table.indexes.length)
-          return yield* new AppDatabaseError({ reason: "schema" });
-        for (const field2 of Object.values(table.fields)) {
-          if ((field2.kind === "id" ? field2.references === void 0 : field2.references !== void 0) || field2.default !== void 0 && !validScalar(field2, field2.default) || field2.references !== void 0 && !Object.hasOwn(schema, field2.references))
-            return yield* new AppDatabaseError({ reason: "schema" });
-        }
-        for (const index of table.indexes)
-          if (index.name === "by_creation" || new Set(index.fields).size !== index.fields.length || index.fields.some((name2) => fieldFor(table, name2) === void 0))
-            return yield* new AppDatabaseError({ reason: "schema" });
-      }
-      return schema;
-    })
-  )
-);
-var canonicalSchema = (schema) => JSON.stringify(
-  Object.fromEntries(
-    Object.entries(schema).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, table]) => [
-      name,
-      {
-        fields: Object.fromEntries(
-          Object.entries(table.fields).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([field, definition]) => [
-            field,
-            {
-              kind: definition.kind,
-              optional: definition.optional === true,
-              ...definition.default === void 0 ? {} : { default: definition.default },
-              ...definition.references === void 0 ? {} : { references: definition.references }
-            }
-          ])
-        ),
-        indexes: [...table.indexes].sort(
-          (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
-        )
-      }
-    ])
-  )
-);
-var writeValue = (table, values, previous, meta) => Effect_exports.gen(function* () {
-  if (Object.keys(values).some((name) => metadata.has(name) || !Object.hasOwn(table.fields, name)))
-    return yield* new AppDatabaseError({ reason: "value" });
-  const row = { ...meta };
-  for (const [name, field] of Object.entries(table.fields)) {
-    const supplied = Object.hasOwn(values, name) ? values[name] : previous?.[name];
-    if (supplied === null && !field.optional)
-      return yield* new AppDatabaseError({ reason: "value" });
-    const value = supplied === null || supplied === void 0 ? field.default : supplied;
-    if (value === void 0) {
-      if (!field.optional) return yield* new AppDatabaseError({ reason: "value" });
-    } else {
-      if (!validScalar(field, value)) return yield* new AppDatabaseError({ reason: "value" });
-      row[name] = value;
-    }
-  }
-  return row;
-});
-
-// ../app-data/src/implementation/cursor.ts
-var Payload = Schema_exports.Struct({
-  version: Schema_exports.Literal(1),
-  query: Schema_exports.String,
-  key: Schema_exports.String
-});
-var fingerprint = (crypto, value) => Effect_exports.tryPromise({
-  try: async () => Encoding_exports.encodeBase64Url(
-    new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)))
-  ),
-  catch: () => new AppDatabaseError({ reason: "storage" })
-});
-var cursorCodec = (crypto, bytes) => Effect_exports.gen(function* () {
-  const key = yield* Effect_exports.tryPromise({
-    try: () => crypto.subtle.importKey("raw", new Uint8Array(bytes), "AES-GCM", false, [
-      "encrypt",
-      "decrypt"
-    ]),
-    catch: () => new AppDatabaseError({ reason: "storage" })
-  });
-  return {
-    encode: (query, position) => Effect_exports.tryPromise({
-      try: async () => {
-        const nonce = crypto.getRandomValues(new Uint8Array(12));
-        const plaintext = new TextEncoder().encode(
-          JSON.stringify({ version: 1, query, key: Encoding_exports.encodeBase64Url(position) })
-        );
-        const ciphertext = new Uint8Array(
-          await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, key, plaintext)
-        );
-        const token = new Uint8Array(nonce.length + ciphertext.length);
-        token.set(nonce);
-        token.set(ciphertext, nonce.length);
-        return Encoding_exports.encodeBase64Url(token);
-      },
-      catch: () => new AppDatabaseError({ reason: "cursor" })
-    }),
-    decode: (query, token) => Effect_exports.gen(function* () {
-      if (token.length > defaultDatabaseRuntimeLimits.maxCursorChars)
-        return yield* new AppDatabaseError({ reason: "cursor" });
-      const encoded = yield* Effect_exports.fromResult(Encoding_exports.decodeBase64Url(token));
-      if (encoded.length < 28) return yield* new AppDatabaseError({ reason: "cursor" });
-      const plain = yield* Effect_exports.tryPromise(
-        () => crypto.subtle.decrypt(
-          { name: "AES-GCM", iv: new Uint8Array(encoded.slice(0, 12)) },
-          key,
-          new Uint8Array(encoded.slice(12))
-        )
-      );
-      const payload = yield* Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonString(Payload))(
-        new TextDecoder().decode(plain)
-      );
-      if (payload.query !== query) return yield* new AppDatabaseError({ reason: "cursor" });
-      return yield* Effect_exports.fromResult(Encoding_exports.decodeBase64Url(payload.key));
-    }).pipe(Effect_exports.mapError(() => new AppDatabaseError({ reason: "cursor" })))
-  };
-});
-
-// ../app-data/src/implementation/index-key.ts
-var encodeIndexKey = (values, maximum = defaultDatabaseLimits.indexBytes) => Effect_exports.try({
-  try: () => {
-    const bytes = [1];
-    for (const value of values) {
-      if (value === null) bytes.push(1);
-      else if (typeof value === "boolean") bytes.push(value ? 17 : 16);
-      else if (typeof value === "string") {
-        if ([...value].some((character) => {
-          const code = character.codePointAt(0);
-          return code !== void 0 && code >= 55296 && code <= 57343;
-        }))
-          throw new Error("Invalid string");
-        bytes.push(32);
-        for (const byte of new TextEncoder().encode(value)) {
-          bytes.push(byte);
-          if (byte === 0) bytes.push(255);
-        }
-        bytes.push(0, 0);
-      } else {
-        if (!Number.isFinite(value)) throw new Error("Invalid number");
-        const view = new DataView(new ArrayBuffer(8));
-        view.setFloat64(0, value === 0 ? 0 : value, false);
-        const encoded = new Uint8Array(view.buffer);
-        if (value < 0) for (const [i, byte] of encoded.entries()) encoded[i] = 255 ^ byte;
-        else view.setUint8(0, view.getUint8(0) ^ 128);
-        bytes.push(48, ...encoded);
-      }
-      if (bytes.length > maximum) throw new Error("Index key too long");
-    }
-    return Uint8Array.from(bytes);
-  },
-  catch: () => new AppDatabaseError({ reason: "value" })
-});
-var prefixEnd = (prefix) => {
-  const result = prefix.slice();
-  for (let i = result.length - 1; i >= 0; i--) {
-    const byte = result[i];
-    if (byte !== void 0 && byte < 255) {
-      result[i] = byte + 1;
-      return result.slice(0, i + 1);
-    }
-  }
-  return void 0;
-};
-
-// ../app-data/src/implementation/range.ts
-var queryBounds = (table, plan, maximum) => Effect_exports.gen(function* () {
-  const index = indexesFor(table).find((index2) => index2.name === plan.index);
-  if (index === void 0) return yield* new AppDatabaseError({ reason: "index" });
-  const equal = [];
-  let rangeField;
-  let lower;
-  let upper;
-  let lowerSet = false;
-  let upperSet = false;
-  for (const clause of plan.clauses) {
-    const expected = rangeField === void 0 ? index.fields[equal.length] : rangeField;
-    const field = fieldFor(table, clause.field);
-    if (expected !== clause.field || field === void 0)
-      return yield* new AppDatabaseError({ reason: "range" });
-    if (clause.op === "eq") {
-      if (rangeField !== void 0 || (clause.value === null ? !field.optional : !validScalar(field, clause.value)))
-        return yield* new AppDatabaseError({ reason: "range" });
-      equal.push(clause.value);
-    } else {
-      if (!validScalar(field, clause.value))
-        return yield* new AppDatabaseError({ reason: "range" });
-      rangeField = clause.field;
-      const encoded = yield* encodeIndexKey([...equal, clause.value], maximum);
-      if (clause.op === "gt" || clause.op === "gte") {
-        if (lowerSet) return yield* new AppDatabaseError({ reason: "range" });
-        lowerSet = true;
-        lower = clause.op === "gt" ? prefixEnd(encoded) : encoded;
-      } else {
-        if (upperSet) return yield* new AppDatabaseError({ reason: "range" });
-        upperSet = true;
-        upper = clause.op === "lte" ? prefixEnd(encoded) : encoded;
-      }
-    }
-  }
-  const prefix = yield* encodeIndexKey(equal, maximum);
-  if (rangeField !== void 0 && !lowerSet)
-    lower = prefixEnd(yield* encodeIndexKey([...equal, null], maximum));
-  return { lower: lower ?? prefix, upper: upper ?? prefixEnd(prefix) };
-});
-
-// ../app-data/src/implementation/sqlite.ts
-var Saved = Schema_exports.Struct({ schema_hash: Schema_exports.String, cursor_key: Schema_exports.String });
-var StoredRow = Schema_exports.Struct({ body: Schema_exports.String });
-var ScanRow = Schema_exports.Struct({ sort_key: Schema_exports.Uint8Array, body: Schema_exports.String });
-var CountRow = Schema_exports.Struct({ sort_key: Schema_exports.Uint8Array });
-var decodeRows = Schema_exports.decodeUnknownEffect(Schema_exports.Array(StoredRow));
-var decodeBody = Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonString(Row));
-var storageError = () => new AppDatabaseError({ reason: "storage" });
-var makeSqliteDatabase = (options) => Effect_exports.gen(function* () {
-  const { sql, crypto } = options;
-  const schema = yield* parseDatabaseSchema(options.schema).pipe(
-    Effect_exports.catchTag(
-      "DatabaseFieldReserved",
-      () => Effect_exports.fail(new AppDatabaseError({ reason: "schema" }))
-    )
-  );
-  const limits = yield* Schema_exports.decodeUnknownEffect(DatabaseLimits)(
-    options.limits ?? defaultDatabaseLimits
-  ).pipe(Effect_exports.mapError(() => new AppDatabaseError({ reason: "limit" })));
-  const schemaHash = yield* fingerprint(crypto, canonicalSchema(schema));
-  const key = yield* sql.withTransaction(
-    Effect_exports.gen(function* () {
-      yield* sql`CREATE TABLE IF NOT EXISTS app_database (singleton INTEGER PRIMARY KEY CHECK (singleton = 1), schema_hash TEXT NOT NULL, cursor_key TEXT NOT NULL)`;
-      yield* sql`CREATE TABLE IF NOT EXISTS app_rows (table_name TEXT NOT NULL, id TEXT NOT NULL, body TEXT NOT NULL, PRIMARY KEY (table_name, id)) WITHOUT ROWID`;
-      yield* sql`CREATE TABLE IF NOT EXISTS app_indexes (table_name TEXT NOT NULL, index_name TEXT NOT NULL, sort_key BLOB NOT NULL, row_id TEXT NOT NULL, PRIMARY KEY (table_name, index_name, sort_key)) WITHOUT ROWID`;
-      yield* sql`CREATE TABLE IF NOT EXISTS app_mutation_receipts (id TEXT PRIMARY KEY, fingerprint TEXT NOT NULL, result TEXT NOT NULL) WITHOUT ROWID`;
-      yield* sql`CREATE INDEX IF NOT EXISTS app_indexes_by_row ON app_indexes (table_name, row_id)`;
-      const generated = Encoding_exports.encodeBase64Url(crypto.getRandomValues(new Uint8Array(32)));
-      yield* sql`INSERT OR IGNORE INTO app_database (singleton, schema_hash, cursor_key) VALUES (1, ${schemaHash}, ${generated})`;
-      const saved = yield* sql`SELECT schema_hash, cursor_key FROM app_database WHERE singleton = 1`.pipe(
-        Effect_exports.flatMap((rows) => Schema_exports.decodeUnknownEffect(Saved)(rows[0]))
-      );
-      if (saved.schema_hash !== schemaHash)
-        return yield* new AppDatabaseError({ reason: "schema_changed" });
-      return yield* Effect_exports.fromResult(Encoding_exports.decodeBase64Url(saved.cursor_key));
-    })
-  ).pipe(
-    Effect_exports.catchTags({
-      SqlError: () => Effect_exports.fail(storageError()),
-      SchemaError: () => Effect_exports.fail(storageError()),
-      EncodingError: () => Effect_exports.fail(storageError())
-    })
-  );
-  const cursors = yield* cursorCodec(crypto, key);
-  const run = (writable, work) => sql.withTransaction(
-    Effect_exports.gen(function* () {
-      const context = yield* Effect_exports.context();
-      const gate = yield* Semaphore_exports.make(1);
-      const reads = /* @__PURE__ */ new Set();
-      const changes = /* @__PURE__ */ new Set();
-      let active = true;
-      let failed;
-      const used = {
-        rowsRead: 0,
-        rowsReturned: 0,
-        bytesRead: 0,
-        writes: 0,
-        scanCalls: 0,
-        directGets: 0
-      };
-      const charge = (name, amount) => Effect_exports.suspend(() => {
-        used[name] += amount;
-        return used[name] > limits[name] ? Effect_exports.fail(
-          new DatabaseLimitExceeded({
-            limit: name,
-            maximum: limits[name],
-            requested: used[name]
-          })
-        ) : Effect_exports.void;
-      });
-      const get = (table, id) => Effect_exports.gen(function* () {
-        yield* charge("directGets", 1);
-        reads.add(table);
-        const records = yield* sql`SELECT body FROM app_rows WHERE table_name = ${table} AND id = ${id}`.pipe(
-          Effect_exports.flatMap(decodeRows)
-        );
-        const record = records[0];
-        if (record === void 0) return null;
-        yield* charge("rowsRead", 1);
-        yield* charge("bytesRead", new TextEncoder().encode(record.body).length);
-        return yield* decodeBody(record.body);
-      });
-      const store = (tableName, table, row) => Effect_exports.gen(function* () {
-        const meta = yield* Schema_exports.decodeUnknownEffect(RowMetadata)(row);
-        const body = JSON.stringify(row);
-        const bytes = new TextEncoder().encode(body).length;
-        if (bytes > limits.valueBytes)
-          return yield* new DatabaseLimitExceeded({
-            limit: "valueBytes",
-            maximum: limits.valueBytes,
-            requested: bytes
-          });
-        const keys = yield* Effect_exports.forEach(
-          indexesFor(table),
-          (index) => encodeIndexKey(
-            index.fields.map(
-              (field) => Object.hasOwn(row, field) ? row[field] ?? null : null
-            ),
-            limits.indexBytes
-          ).pipe(Effect_exports.map((key2) => ({ name: index.name, key: key2 })))
-        );
-        yield* sql`INSERT INTO app_rows (table_name, id, body) VALUES (${tableName}, ${meta.id}, ${body}) ON CONFLICT(table_name, id) DO UPDATE SET body = excluded.body`;
-        yield* sql`DELETE FROM app_indexes WHERE table_name = ${tableName} AND row_id = ${meta.id}`;
-        for (const index of keys)
-          yield* sql`INSERT INTO app_indexes (table_name, index_name, sort_key, row_id) VALUES (${tableName}, ${index.name}, ${index.key}, ${meta.id})`;
-        changes.add(tableName);
-        return row;
-      });
-      const execute = (input) => gate.withPermits(1)(
-        Effect_exports.gen(function* () {
-          if (!active) return yield* new AppDatabaseError({ reason: "closed" });
-          if (failed !== void 0) return yield* failed;
-          const operation = yield* Schema_exports.decodeUnknownEffect(DatabaseOperation)(
-            input
-          ).pipe(Effect_exports.mapError(() => new AppDatabaseError({ reason: "value" })));
-          const tableName = operation.kind === "query" ? operation.plan.table : operation.table;
-          const table = Object.hasOwn(schema, tableName) ? schema[tableName] : void 0;
-          if (table === void 0) return yield* new AppDatabaseError({ reason: "table" });
-          switch (operation.kind) {
-            case "get": {
-              const row = yield* get(tableName, operation.id);
-              if (row !== null) yield* charge("rowsReturned", 1);
-              return row;
-            }
-            case "insert": {
-              if (!writable) return yield* new AppDatabaseError({ reason: "readonly" });
-              yield* charge("writes", 1);
-              const timestamp = new Date(yield* Clock_exports.currentTimeMillis).toISOString();
-              const row = yield* writeValue(table, operation.value, void 0, {
-                id: crypto.randomUUID(),
-                createdAt: timestamp,
-                updatedAt: timestamp
-              });
-              return yield* store(tableName, table, row);
-            }
-            case "update": {
-              if (!writable) return yield* new AppDatabaseError({ reason: "readonly" });
-              yield* charge("writes", 1);
-              const before = yield* get(tableName, operation.id);
-              if (before === null) return null;
-              const meta = yield* Schema_exports.decodeUnknownEffect(RowMetadata)(before);
-              const row = yield* writeValue(table, operation.patch, before, {
-                ...meta,
-                updatedAt: new Date(yield* Clock_exports.currentTimeMillis).toISOString()
-              });
-              return yield* store(tableName, table, row);
-            }
-            case "delete": {
-              if (!writable) return yield* new AppDatabaseError({ reason: "readonly" });
-              yield* charge("writes", 1);
-              const before = yield* get(tableName, operation.id);
-              if (before === null) return false;
-              yield* sql`DELETE FROM app_rows WHERE table_name = ${tableName} AND id = ${operation.id}`;
-              yield* sql`DELETE FROM app_indexes WHERE table_name = ${tableName} AND row_id = ${operation.id}`;
-              changes.add(tableName);
-              return true;
-            }
-            case "query": {
-              const { plan, terminal } = operation;
-              const bounds = yield* queryBounds(table, plan, limits.indexBytes);
-              reads.add(tableName);
-              yield* charge("scanCalls", 1);
-              const remaining = terminal.kind === "count" ? limits.rowsRead - used.rowsRead : limits.rowsReturned - used.rowsReturned;
-              const count = terminal.kind === "first" ? 1 : terminal.kind === "take" ? terminal.count : terminal.kind === "paginate" ? terminal.numItems : remaining;
-              if ((terminal.kind === "take" || terminal.kind === "paginate") && count > limits.rowsReturned)
-                return yield* new DatabaseLimitExceeded({
-                  limit: "pageSize",
-                  maximum: limits.rowsReturned,
-                  requested: count
-                });
-              if (count === 0 && terminal.kind === "take") return [];
-              const query = yield* fingerprint(
-                crypto,
-                JSON.stringify({
-                  schemaHash,
-                  table: tableName,
-                  index: plan.index,
-                  order: plan.order,
-                  lower: Encoding_exports.encodeBase64Url(bounds.lower),
-                  upper: bounds.upper === void 0 ? null : Encoding_exports.encodeBase64Url(bounds.upper)
-                })
-              );
-              const position = terminal.kind === "paginate" && terminal.cursor !== null ? yield* cursors.decode(query, terminal.cursor) : void 0;
-              const predicates = [
-                sql`i.table_name = ${tableName}`,
-                sql`i.index_name = ${plan.index}`,
-                sql`i.sort_key >= ${bounds.lower}`
-              ];
-              if (bounds.upper !== void 0)
-                predicates.push(sql`i.sort_key < ${bounds.upper}`);
-              if (position !== void 0)
-                predicates.push(
-                  plan.order === "asc" ? sql`i.sort_key > ${position}` : sql`i.sort_key < ${position}`
-                );
-              const direction = plan.order === "asc" ? sql.literal("ASC") : sql.literal("DESC");
-              const limit = Math.min(
-                terminal.kind === "first" || terminal.kind === "take" ? count : count + 1,
-                remaining + 1
-              );
-              if (terminal.kind === "count") {
-                const rows2 = yield* sql`SELECT i.sort_key FROM app_indexes i WHERE ${sql.and(predicates)} ORDER BY i.sort_key ${direction} LIMIT ${limit}`.pipe(
-                  Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(CountRow)))
-                );
-                yield* charge("rowsRead", rows2.length);
-                yield* charge(
-                  "bytesRead",
-                  rows2.reduce((sum, row) => sum + row.sort_key.byteLength, 0)
-                );
-                return rows2.length;
-              }
-              const rows = yield* sql`SELECT i.sort_key, r.body FROM app_indexes i JOIN app_rows r ON r.table_name = i.table_name AND r.id = i.row_id WHERE ${sql.and(predicates)} ORDER BY i.sort_key ${direction} LIMIT ${limit}`.pipe(
-                Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(ScanRow)))
-              );
-              yield* charge("rowsRead", rows.length);
-              yield* charge(
-                "bytesRead",
-                rows.reduce(
-                  (sum, row) => sum + new TextEncoder().encode(row.body).length + row.sort_key.byteLength,
-                  0
-                )
-              );
-              if (terminal.kind === "collect" && rows.length > count)
-                return yield* new DatabaseLimitExceeded({
-                  limit: "rowsReturned",
-                  maximum: limits.rowsReturned,
-                  requested: used.rowsReturned + rows.length
-                });
-              const page = rows.slice(0, count);
-              yield* charge("rowsReturned", page.length);
-              const values = yield* Effect_exports.forEach(page, (row) => decodeBody(row.body));
-              if (terminal.kind === "first") return values[0] ?? null;
-              if (terminal.kind !== "paginate") return values;
-              const last = page.at(-1);
-              const isDone = rows.length <= count;
-              return {
-                page: values,
-                isDone,
-                continueCursor: isDone || last === void 0 ? null : yield* cursors.encode(query, last.sort_key)
-              };
-            }
-          }
-        }).pipe(
-          Effect_exports.catchTags({
-            SqlError: () => Effect_exports.fail(storageError()),
-            SchemaError: () => Effect_exports.fail(storageError())
-          }),
-          Effect_exports.tapError(
-            (error) => Effect_exports.sync(() => {
-              failed = error;
-            })
-          ),
-          Effect_exports.provideContext(context)
-        )
-      );
-      const session = {
-        readTables: reads,
-        changedTables: changes,
-        execute,
-        once: (key2, expected, work2) => Effect_exports.gen(function* () {
-          if (!active) return yield* new AppDatabaseError({ reason: "closed" });
-          if (!writable) return yield* new AppDatabaseError({ reason: "readonly" });
-          const rows = yield* sql`SELECT fingerprint, result FROM app_mutation_receipts WHERE id = ${key2}`.pipe(
-            Effect_exports.flatMap(
-              Schema_exports.decodeUnknownEffect(
-                Schema_exports.Array(
-                  Schema_exports.Struct({ fingerprint: Schema_exports.String, result: Schema_exports.String })
-                )
-              )
-            ),
-            Effect_exports.mapError(storageError)
-          );
-          const saved = rows[0];
-          if (saved !== void 0) {
-            if (saved.fingerprint !== expected)
-              return yield* new AppDatabaseError({ reason: "replay" });
-            return yield* Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonString(Schema_exports.Json))(
-              saved.result
-            ).pipe(Effect_exports.mapError(storageError));
-          }
-          const result = yield* work2();
-          const encoded = yield* Schema_exports.encodeEffect(Schema_exports.fromJsonString(Schema_exports.Json))(
-            result
-          ).pipe(Effect_exports.mapError(storageError));
-          if (new TextEncoder().encode(encoded).byteLength > 1024 * 1024)
-            return yield* new AppDatabaseError({ reason: "limit" });
-          yield* sql`INSERT INTO app_mutation_receipts (id, fingerprint, result) VALUES (${key2}, ${expected}, ${encoded})`.pipe(
-            Effect_exports.mapError(storageError)
-          );
-          return result;
-        })
-      };
-      return yield* Effect_exports.suspend(() => work(session)).pipe(
-        // A failed database call poisons the session. Report that failure even when
-        // authored code caught it or threw something else in its place.
-        Effect_exports.catchCause(
-          (cause) => failed === void 0 || Cause_exports.hasInterrupts(cause) ? Effect_exports.failCause(cause) : Effect_exports.fail(failed)
-        ),
-        Effect_exports.tap(
-          () => gate.withPermits(1)(
-            Effect_exports.suspend(() => failed === void 0 ? Effect_exports.void : Effect_exports.fail(failed))
-          )
-        ),
-        Effect_exports.ensuring(
-          Effect_exports.sync(() => {
-            active = false;
-          })
-        )
-      );
-    })
-  ).pipe(Effect_exports.catchTag("SqlError", () => Effect_exports.fail(storageError())));
-  return {
-    schema,
-    schemaHash,
-    read: (work) => run(false, work),
-    mutate: (work) => run(true, work)
-  };
-});
-
-// ../app-data/src/implementation/promise.ts
-var promiseTable = (session, table, signal) => {
-  const execute = (input) => Effect_exports.runPromise(
-    Schema_exports.decodeUnknownEffect(DatabaseOperation)(input).pipe(Effect_exports.flatMap(session.execute)),
-    { signal }
-  );
-  const query = (plan) => ({
-    order: (direction) => query({ ...plan, order: direction }),
-    collect: async () => Schema_exports.decodeUnknownSync(Schema_exports.Array(Row))(
-      await execute({ kind: "query", plan, terminal: { kind: "collect" } })
-    ),
-    count: async () => Schema_exports.decodeUnknownSync(Schema_exports.Int)(
-      await execute({ kind: "query", plan, terminal: { kind: "count" } })
-    ),
-    first: async () => Schema_exports.decodeUnknownSync(Schema_exports.NullOr(Row))(
-      await execute({ kind: "query", plan, terminal: { kind: "first" } })
-    ),
-    take: async (count) => Schema_exports.decodeUnknownSync(Schema_exports.Array(Row))(
-      await execute({ kind: "query", plan, terminal: { kind: "take", count } })
-    ),
-    paginate: async (options) => Schema_exports.decodeUnknownSync(PaginationResult)(
-      await execute({ kind: "query", plan, terminal: { kind: "paginate", ...options } })
-    )
-  });
-  return {
-    get: async (id) => Schema_exports.decodeUnknownSync(Schema_exports.NullOr(Row))(await execute({ kind: "get", table, id })),
-    insert: async (value) => Schema_exports.decodeUnknownSync(Row)(await execute({ kind: "insert", table, value })),
-    update: async (id, patch) => Schema_exports.decodeUnknownSync(Schema_exports.NullOr(Row))(
-      await execute({ kind: "update", table, id, patch })
-    ),
-    delete: async (id) => Schema_exports.decodeUnknownSync(Schema_exports.Boolean)(await execute({ kind: "delete", table, id })),
-    withIndex: (index, range) => {
-      const ranges = /* @__PURE__ */ new WeakMap();
-      const makeRange = (clauses2) => {
-        const predicate = (op) => (field, value) => makeRange([
-          ...clauses2,
-          Schema_exports.decodeUnknownSync(RangeClause)({
-            field,
-            op,
-            value: op === "eq" && value === void 0 ? null : value
-          })
-        ]);
-        const result = {
-          eq: predicate("eq"),
-          gt: predicate("gt"),
-          gte: predicate("gte"),
-          lt: predicate("lt"),
-          lte: predicate("lte")
-        };
-        ranges.set(result, clauses2);
-        return result;
-      };
-      const selected = range === void 0 ? makeRange([]) : range(makeRange([]));
-      const clauses = ranges.get(selected);
-      if (clauses === void 0) throw new Error("Return the supplied index range");
-      return query({ table, index, order: "asc", clauses });
-    }
-  };
-};
-
-export {
-  parseDatabaseSchema,
-  makeSqliteDatabase,
-  promiseTable
-};

package/types/app-data/src/implementation/cursor.d.ts

@@ -1,10 +0,0 @@
-/** Authenticated, opaque continuation tokens tied to one installation, schema and query plan. */
-import { Effect } from "effect";
-import { AppDatabaseError } from "../contracts/database.js";
-/** Stable SHA-256 fingerprints contain no raw query arguments in logs or metadata keys. */
-export declare const fingerprint: (crypto: Crypto, value: string) => Effect.Effect<string, AppDatabaseError, never>;
-/** Capture a per-database key. Nonces are fresh, and malformed/tampered/cross-query cursors fail closed. */
-export declare const cursorCodec: (crypto: Crypto, bytes: Uint8Array) => Effect.Effect<{
-    encode: (query: string, position: Uint8Array) => Effect.Effect<string, AppDatabaseError, never>;
-    decode: (query: string, token: string) => Effect.Effect<Uint8Array<ArrayBufferLike>, AppDatabaseError, never>;
-}, AppDatabaseError, never>;

package/types/app-data/src/implementation/index-key.d.ts

@@ -1,7 +0,0 @@
-/** Order-preserving scalar tuples. SQLite BLOB ordering supplies bounded prefix/range scans. */
-import { Effect } from "effect";
-import { AppDatabaseError, type Scalar } from "../contracts/database.js";
-/** Compare UTF-8 strings, booleans and finite doubles consistently, with absence before present values. */
-export declare const encodeIndexKey: (values: readonly (Scalar | null)[], maximum?: number) => Effect.Effect<Uint8Array<ArrayBuffer>, AppDatabaseError, never>;
-/** Exclusive upper bound for all tuples beginning with this prefix. */
-export declare const prefixEnd: (prefix: Uint8Array) => Uint8Array | undefined;