apps 0.0.1-beta.0

package/js/chunk-R6JMJSVT.js

@@ -0,0 +1,590 @@
+import {
+  AppDatabaseError,
+  DatabaseLimits,
+  DatabaseOperation,
+  DatabaseSchema,
+  PaginationResult,
+  RangeClause,
+  Row,
+  RowMetadata,
+  defaultDatabaseLimits,
+  defaultDatabaseRuntimeLimits
+} from "./chunk-7JXHF5IF.js";
+import {
+  Clock_exports,
+  Effect_exports,
+  Encoding_exports,
+  Schema_exports,
+  Semaphore_exports
+} from "./chunk-2OTCEKL2.js";
+
+// ../app-data/src/implementation/schema.ts
+var metadata = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+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.flatMap(
+    (schema) => Effect_exports.gen(function* () {
+      for (const table of Object.values(schema)) {
+        if (Object.keys(table.fields).some((name) => metadata.has(name)) || new Set(table.indexes.map((index) => index.name)).size !== table.indexes.length)
+          return yield* new AppDatabaseError({ reason: "schema" });
+        for (const field of Object.values(table.fields)) {
+          if ((field.kind === "id" ? field.references === void 0 : field.references !== void 0) || field.default !== void 0 && !validScalar(field, field.default) || field.references !== void 0 && !Object.hasOwn(schema, field.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((name) => fieldFor(table, name) === void 0))
+            return yield* new AppDatabaseError({ reason: "schema" });
+      }
+      return schema;
+    })
+  ),
+  Effect_exports.mapError(() => new AppDatabaseError({ reason: "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);
+  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 AppDatabaseError({ reason: "limit" })) : 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);
+        if (new TextEncoder().encode(body).length > limits.valueBytes)
+          return yield* new AppDatabaseError({ reason: "limit" });
+        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 maximum = 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 : maximum;
+              if (count > maximum) return yield* new AppDatabaseError({ reason: "limit" });
+              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 = terminal.kind === "first" || terminal.kind === "take" ? count : count + 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 AppDatabaseError({ reason: "limit" });
+              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(
+        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/js/chunk-SBKHUC5L.js

@@ -0,0 +1,56 @@
+import {
+  HttpApiEndpoint_exports,
+  HttpApiGroup_exports,
+  HttpApi_exports,
+  UiFailed,
+  UiForbidden,
+  UiUnauthorized
+} from "./chunk-3ANFZFCV.js";
+import {
+  Schema_exports
+} from "./chunk-2OTCEKL2.js";
+
+// src/contracts/ui-auth.ts
+var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/)).pipe(
+  Schema_exports.brand("AppSignInId")
+);
+var AppSignInCode = Schema_exports.RedactedFromValue(
+  Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/))
+);
+var AppReturnPath = Schema_exports.String.check(
+  Schema_exports.isMaxLength(8192),
+  Schema_exports.makeFilter((value) => {
+    if (!value.startsWith("/") || value.startsWith("//") || /[\\\u0000-\u0020\u007f]/.test(value))
+      return false;
+    try {
+      const url = new URL(value, "https://app.invalid");
+      return url.origin === "https://app.invalid" && !/^\/(?:_executor|dashboard|auth|v1|mcp)(?:\/|$)/.test(decodeURIComponent(url.pathname));
+    } catch {
+      return false;
+    }
+  })
+).pipe(Schema_exports.brand("AppReturnPath"));
+var AppSignInCallback = Schema_exports.Struct({ request: AppSignInId, code: AppSignInCode });
+var AppSignInApi = HttpApi_exports.make("app-sign-in").add(
+  HttpApiGroup_exports.make("appSignIn").add(
+    HttpApiEndpoint_exports.post("start", "/_executor/auth/start", {
+      payload: Schema_exports.Struct({ returnTo: AppReturnPath }),
+      success: Schema_exports.Struct({ url: Schema_exports.String }),
+      error: [UiForbidden, UiFailed]
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("complete", "/_executor/auth/complete", {
+      payload: AppSignInCallback,
+      success: Schema_exports.Struct({ returnTo: AppReturnPath }),
+      error: [UiUnauthorized, UiForbidden, UiFailed]
+    })
+  )
+);
+
+export {
+  AppSignInId,
+  AppSignInCode,
+  AppReturnPath,
+  AppSignInCallback,
+  AppSignInApi
+};