ignotum 0.0.7 → 0.0.8

package/src/cli/new-app.ts

@@ -207,6 +207,17 @@ Open <http://127.0.0.1:3210>.
 The app generator creates \`_generated\`. The dev server checks those files before it starts
 and updates them when the schema or server functions change.
 
+## Deploy
+
+Set \`IGNOTUM_API_TOKEN\`, then choose a unique slug on the first deployment:
+
+\`\`\`sh
+npx ignotum deploy --app my-app
+\`\`\`
+
+The command prints the hosted URL and records the app link in \`.ignotum/app.json\`. Later
+deployments use \`npx ignotum deploy\` without the \`--app\` flag.
+
 ## App files
 
 - \`server/schema.ts\` defines the database tables.
@@ -216,6 +227,7 @@ and updates them when the schema or server functions change.
 - Ignotum loads Tailwind CSS automatically. Custom CSS files are ordinary client modules.
 - \`shared/utils.ts\` contains code shared across the app.
 - \`_generated\` contains Ignotum's generated types and bindings. Do not edit it by hand.
+- \`.agents/skills/ignotum\` contains the app skill and references used by coding agents.
 
 Run the typechecker after a change:
 
@@ -224,6 +236,9 @@ npx ignotum codegen
 npx tsc --noEmit
 \`\`\`
 
+The [Ignotum documentation](https://docs.ignotum.cloud) covers schema values, indexes, queries,
+mutations, client hooks, deployment, guarantees, and hosted limits.
+
 ## Claude Code
 
 If you use Claude Code, rename \`AGENTS.md\` to \`CLAUDE.md\` and \`.agents\` to \`.claude\` so it

package/src/client/files.ts

@@ -0,0 +1,168 @@
+import {
+  FileId,
+  fileGrantUrlOf,
+  fileIdOf,
+  fileFormats,
+  fileLimits,
+  fileMimeTypes,
+  grantFileValue,
+  isFileValue,
+  makeFileValue,
+  type FileFormat,
+  type FileValue,
+  type RuntimeFileOccurrence,
+} from "@ignotum/contracts/schema/file";
+import { IdGenerator } from "@ignotum/shared/id";
+import { Effect, Predicate } from "effect";
+
+export const Files = {
+  url: (file: FileValue): string => {
+    const url = fileGrantUrlOf(file);
+    if (url === undefined) {
+      throw new Error("This FileValue has no active query grant.");
+    }
+    return url;
+  },
+} as const;
+
+const formatByMime: Partial<Record<string, FileFormat>> = {};
+for (const format of fileFormats) formatByMime[fileMimeTypes[format]] = format;
+
+interface NativeOccurrence {
+  readonly path: ReadonlyArray<string | number>;
+  readonly value: File;
+}
+
+const collectNativeFiles = (
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- This is the recursive parser for generated mutation arguments and native File values.
+  value: unknown,
+  path: ReadonlyArray<string | number>,
+  occurrences: Array<NativeOccurrence>,
+): void => {
+  if (value instanceof File) {
+    occurrences.push({ path, value });
+    return;
+  }
+  if (isFileValue(value) || Predicate.isDate(value)) return;
+  if (globalThis.Array.isArray(value)) {
+    for (const [index, child] of value.entries())
+      collectNativeFiles(child, [...path, index], occurrences);
+    return;
+  }
+  if (!Predicate.isObject(value)) return;
+  for (const [key, child] of Object.entries(value))
+    collectNativeFiles(child, [...path, key], occurrences);
+};
+
+const replaceNativeFiles = (
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Each node is classified before it is copied into the transport value.
+  value: unknown,
+  replacements: ReadonlyMap<File, FileValue>,
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- The generated function schema validates the reconstructed argument value on the server.
+): unknown => {
+  if (value instanceof File) return replacements.get(value);
+  if (isFileValue(value) || Predicate.isDate(value)) return value;
+  if (globalThis.Array.isArray(value))
+    return value.map((child) => replaceNativeFiles(child, replacements));
+  if (!Predicate.isObject(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [key, replaceNativeFiles(child, replacements)]),
+  );
+};
+
+export interface PreparedMutationArguments {
+  readonly value: unknown;
+  readonly nativeFiles: ReadonlyMap<FileId, File>;
+  readonly occurrences: ReadonlyArray<RuntimeFileOccurrence>;
+}
+
+export const prepareMutationArguments = Effect.fn("SyncClient.prepareMutationArguments")(function* (
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Generated mutation argument types are erased only at this transport preparation boundary.
+  input: unknown,
+) {
+  const ids = yield* IdGenerator;
+  const native: NativeOccurrence[] = [];
+  collectNativeFiles(input, [], native);
+  const unique = new Set(native.map(({ value }) => value));
+  if (unique.size > fileLimits.filesPerMutation) {
+    throw new Error(`A mutation may upload at most ${fileLimits.filesPerMutation} files.`);
+  }
+  const totalBytes = [...unique].reduce((total, file) => total + file.size, 0);
+  if (totalBytes > fileLimits.mutationBytes) {
+    throw new Error(`Mutation uploads may total at most ${fileLimits.mutationBytes} bytes.`);
+  }
+  const replacements = new Map<File, FileValue>();
+  const nativeFiles = new Map<FileId, File>();
+  for (const file of unique) {
+    const format = formatByMime[file.type.toLowerCase()];
+    if (format === undefined) {
+      throw new Error(
+        `File '${file.name}' has unsupported media type '${file.type || "unknown"}'.`,
+      );
+    }
+    if (file.size === 0 || file.size > fileLimits.fileBytes) {
+      throw new Error(`File '${file.name}' must be between 1 and ${fileLimits.fileBytes} bytes.`);
+    }
+    if (new TextEncoder().encode(file.name).byteLength > fileLimits.filenameBytes) {
+      throw new Error(`File '${file.name}' has a filename that is too long.`);
+    }
+    const id = yield* ids.generate(FileId);
+    replacements.set(file, makeFileValue(id, { format, name: file.name, size: file.size }));
+    nativeFiles.set(id, file);
+  }
+  const value = replaceNativeFiles(input, replacements);
+  const occurrences = native.map(({ path, value: file }) => {
+    const replacement = replacements.get(file);
+    if (replacement === undefined) throw new Error("A native file replacement is missing.");
+    return {
+      path,
+      file: {
+        id: fileIdOf(replacement),
+        format: replacement.format,
+        name: replacement.name,
+        size: replacement.size,
+      },
+    } satisfies RuntimeFileOccurrence;
+  });
+  return { value, nativeFiles, occurrences } satisfies PreparedMutationArguments;
+});
+
+interface FileGrantOccurrence extends RuntimeFileOccurrence {
+  readonly url: string;
+}
+
+const pathKey = (path: ReadonlyArray<string | number>): string => JSON.stringify(path);
+
+// @effect-diagnostics-next-line missingPipeableSignature:off File grant attachment naturally takes the decoded value first.
+export const applyFileGrants = (
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Query result types are erased at the wire decoding boundary and checked against grant paths below.
+  value: unknown,
+  grants: ReadonlyArray<FileGrantOccurrence>,
+  // oxlint-disable-next-line anti-slop/no-unknown-returns -- The traversal preserves the decoded query result shape while attaching private symbols.
+): unknown => {
+  const byPath = new Map(grants.map((grant) => [pathKey(grant.path), grant] as const));
+  const visit = (
+    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- This recursive visitor validates a grant and file ID before replacement.
+    current: unknown,
+    path: ReadonlyArray<string | number>,
+    // oxlint-disable-next-line anti-slop/no-unknown-returns -- Recursive branches preserve their input shape.
+  ): unknown => {
+    const grant = byPath.get(pathKey(path));
+    if (grant !== undefined) {
+      if (!isFileValue(current) || fileIdOf(current) !== grant.file.id) {
+        throw new Error("A query file grant does not match its result value.");
+      }
+      return grantFileValue(current, grant.url);
+    }
+    if (globalThis.Array.isArray(current)) {
+      return current.map((child, index) => visit(child, [...path, index]));
+    }
+    if (!Predicate.isObject(current) || Predicate.isDate(current) || isFileValue(current)) {
+      return current;
+    }
+    return Object.fromEntries(
+      Object.entries(current).map(([key, child]) => [key, visit(child, [...path, key])]),
+    );
+  };
+  return visit(value, []);
+};

package/src/client/hooks.ts

@@ -10,11 +10,7 @@ import {
   type PaginationPage,
 } from "@ignotum/contracts/runtime/pagination";
 import { encodeTransportObject } from "@ignotum/contracts/runtime/sync";
-import {
-  ClientInfrastructureError,
-  InvalidMutationArguments,
-  reportClientError,
-} from "./errors.js";
+import { ClientInfrastructureError } from "./errors.js";
 import { isQuerySkip, type QuerySkip } from "./query.js";
 import { SyncClient, syncClientInternals, syncRuntime } from "./sync.js";
 
@@ -278,19 +274,10 @@ export const useMutation = <Args extends object | void, Success, Failure extends
       return syncRuntime.runPromise<SettledResult<Success, Failure>, ClientInfrastructureError>(
         Effect.gen(function* () {
           const client = yield* SyncClient;
-          const jsonArgs = yield* Effect.try({
-            try: () => encodeTransportObject(input),
-            catch: (cause) =>
-              InvalidMutationArguments.make({
-                cause,
-                function: functionPath,
-                message: `Mutation arguments for ${functionPath} contain an unsupported value.`,
-              }),
-          }).pipe(Effect.tapError(reportClientError));
           // SAFETY: generated function references bind the runtime path to the
           // declared public result types validated by the server executor.
           // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- The untyped sync transport deliberately erases the generated reference's result parameters.
-          return (yield* client.mutate(functionPath, jsonArgs)) as unknown as SettledResult<
+          return (yield* client.mutate(functionPath, input)) as unknown as SettledResult<
             Success,
             Failure
           >;

package/src/client/index.ts

@@ -9,6 +9,13 @@ export const Result = { match: contractResult.match };
 export type Result<Value, Error extends ErrorValue> = SettledResult<Value, Error>;
 export type QueryResult<Value, Error extends ErrorValue> = ContractQueryResult<Value, Error>;
 export type { InternalServerError } from "@ignotum/contracts/runtime/result";
+export type {
+  FileFormat,
+  FileMetadata,
+  FileMimeType,
+  FileValue,
+} from "@ignotum/contracts/schema/file";
+export { Files } from "./files.js";
 export { useMutation, usePaginatedQuery, useQuery } from "./hooks.js";
 export type { PaginatedQueryOptions, PaginatedQueryValue, PaginationStatus } from "./hooks.js";
 export { Query } from "./query.js";

package/src/client/sync.ts

@@ -16,6 +16,7 @@ import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
 import { encodeCanonicalJson } from "@ignotum/contracts/json";
 import { type AppStateRevision } from "@ignotum/contracts/runtime/hosted";
 import { IdGenerator } from "@ignotum/shared/id";
+import { encodeTransportObject } from "@ignotum/contracts/runtime/sync";
 
 import type {
   ErrorValue,
@@ -42,10 +43,12 @@ import {
   InvalidClientMessage,
   InvalidServerMessage,
   ServerProtocolError,
+  InvalidMutationArguments,
   clientErrorReporterLayer,
   reportClientError,
 } from "./errors.js";
 import { syncPath } from "../internal/http-paths.js";
+import { applyFileGrants, prepareMutationArguments } from "./files.js";
 
 type Listener = () => void;
 type SocketWriter = (chunk: string) => Effect.Effect<void, Socket.SocketError>;
@@ -195,14 +198,19 @@ const makeQueryCache = (
   } satisfies QueryCache;
 };
 
-const resultFromWire = Effect.fn("SyncClient.resultFromWire")((wire: WireResult) =>
-  Effect.succeed(
-    wire.type === "Success"
-      ? Result.succeed(
-          wire.value === undefined ? undefined : decodeTransportValue(wire.value, wire.dates ?? []),
-        )
-      : failureFromWire(wire.error, wire.dates),
-  ),
+type SnapshotFiles = NonNullable<Extract<ServerMessage, { readonly type: "Snapshot" }>["files"]>;
+
+const resultFromWire = Effect.fn("SyncClient.resultFromWire")(
+  (wire: WireResult, files: SnapshotFiles = []) =>
+    Effect.succeed(
+      wire.type === "Success"
+        ? Result.succeed(
+            wire.value === undefined
+              ? undefined
+              : applyFileGrants(decodeTransportValue(wire.value, wire.dates ?? []), files),
+          )
+        : failureFromWire(wire.error, wire.dates),
+    ),
 );
 
 export const shouldReloadForCloseCode = (code: number): boolean =>
@@ -242,7 +250,8 @@ const socketUrl = (): string => {
 interface SyncClientService {
   readonly mutate: (
     functionAddress: FunctionAddress,
-    args: Schema.Json,
+    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Generated reference argument types are deliberately erased at the client transport boundary.
+    args: unknown,
   ) => Effect.Effect<IgnotumResult<unknown, ErrorValue>, ClientInfrastructureError>;
   readonly observe: (
     functionAddress: FunctionAddress,
@@ -256,7 +265,11 @@ interface PendingInvocation {
     ClientInfrastructureError
   >;
   readonly function: FunctionAddress;
-  readonly message: Extract<ClientMessage, { readonly type: "Invoke" }>;
+  readonly message: Extract<ClientMessage, { readonly type: "Invoke" | "PrepareMutation" }>;
+  readonly prepared: Deferred.Deferred<
+    Extract<ServerMessage, { readonly type: "MutationPrepared" }>["uploads"],
+    ClientInfrastructureError
+  >;
 }
 
 export class SyncClient extends Context.Service<SyncClient, SyncClientService>()(
@@ -319,6 +332,7 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
         }
         invocations = HashMap.remove(invocations, id);
         return reportClientError(error).pipe(
+          Effect.andThen(Deferred.fail(pendingInvocation.prepared, error)),
           Effect.andThen(Deferred.fail(pendingInvocation.deferred, error)),
           Effect.asVoid,
         );
@@ -331,13 +345,20 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
           case "Snapshot": {
             const entry = queryCache.getById(message.id);
             if (entry === undefined) return;
-            yield* resultFromWire(message.result).pipe(
+            yield* resultFromWire(message.result, message.files ?? []).pipe(
               Effect.tap((result) =>
                 Effect.sync(() => queryCache.setResult(message.id, result, message.revision)),
               ),
             );
             return;
           }
+          case "MutationPrepared": {
+            const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+            if (pendingInvocation !== undefined) {
+              yield* Deferred.succeed(pendingInvocation.prepared, message.uploads);
+            }
+            return;
+          }
           case "Result": {
             const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
             if (pendingInvocation === undefined) return;
@@ -488,31 +509,126 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
       const mutate: SyncClientService["mutate"] = Effect.fn("SyncClient.mutate")(
         function* (functionAddress, args) {
           const invocationId = yield* ids.generate(InvocationId);
+          const preparedArguments = yield* prepareMutationArguments(args).pipe(
+            Effect.provideService(IdGenerator, ids),
+            Effect.mapError((cause) =>
+              InvalidMutationArguments.make({
+                cause,
+                function: functionAddress,
+                message: `Mutation arguments for ${functionAddress} contain an unsupported file or value.`,
+              }),
+            ),
+            Effect.tapError(reportClientError),
+          );
+          const jsonArgs = yield* Effect.try({
+            try: () => encodeTransportObject(preparedArguments.value),
+            catch: (cause) =>
+              InvalidMutationArguments.make({
+                cause,
+                function: functionAddress,
+                message: `Mutation arguments for ${functionAddress} contain an unsupported value.`,
+              }),
+          }).pipe(Effect.tapError(reportClientError));
           const deferred = yield* Deferred.make<
             IgnotumResult<unknown, ErrorValue>,
             ClientInfrastructureError
           >();
-          const message: ClientMessage = {
+          const prepared = yield* Deferred.make<
+            Extract<ServerMessage, { readonly type: "MutationPrepared" }>["uploads"],
+            ClientInfrastructureError
+          >();
+          const invokeMessage: Extract<ClientMessage, { readonly type: "Invoke" }> = {
             type: "Invoke",
             id: invocationId,
             kind: "Mutation",
             function: functionAddress,
-            args,
+            args: jsonArgs,
           };
+          const message: PendingInvocation["message"] =
+            preparedArguments.occurrences.length === 0
+              ? invokeMessage
+              : {
+                  type: "PrepareMutation",
+                  id: invocationId,
+                  kind: "Mutation",
+                  function: functionAddress,
+                  args: jsonArgs,
+                  files: preparedArguments.occurrences,
+                };
           invocations = HashMap.set(invocations, invocationId, {
             deferred,
             function: functionAddress,
             message,
+            prepared,
           });
-          if (writer !== undefined) {
-            yield* sendWith(writer, message).pipe(
-              Effect.catchTags({
-                ConnectionUnavailable: reportClientError,
-                InvalidClientMessage: (error) => rejectInvocation(invocationId, error),
+          return yield* Effect.gen(function* () {
+            if (writer !== undefined) {
+              yield* sendWith(writer, message).pipe(
+                Effect.catchTags({
+                  ConnectionUnavailable: reportClientError,
+                  InvalidClientMessage: (error) => rejectInvocation(invocationId, error),
+                }),
+              );
+            }
+            if (message.type === "PrepareMutation") {
+              const uploads = yield* Deferred.await(prepared);
+              const uploaded = new Set<string>();
+              for (const upload of uploads) {
+                if (upload.url === undefined || uploaded.has(upload.file.id)) continue;
+                const uploadUrl = upload.url;
+                uploaded.add(upload.file.id);
+                const file = preparedArguments.nativeFiles.get(upload.file.id);
+                if (file === undefined) {
+                  return yield* InvalidServerMessage.make({
+                    cause: new Error(`Missing native file '${upload.file.id}'.`),
+                    message: "The server prepared an unknown application file.",
+                  });
+                }
+                const response = yield* Effect.tryPromise({
+                  try: () =>
+                    fetch(uploadUrl, {
+                      method: "PUT",
+                      body: file,
+                      headers: { "content-type": file.type },
+                    }),
+                  catch: (cause) =>
+                    ConnectionUnavailable.make({
+                      cause,
+                      message: `File '${file.name}' could not be uploaded.`,
+                    }),
+                });
+                if (!response.ok) {
+                  const detail = yield* Effect.promise(() => response.text());
+                  return yield* InvalidMutationArguments.make({
+                    cause: new Error(detail),
+                    function: functionAddress,
+                    message: `File '${file.name}' was rejected by application storage.`,
+                  });
+                }
+              }
+              const pendingInvocation = HashMap.getUnsafe(invocations, invocationId);
+              if (pendingInvocation === undefined) return yield* Deferred.await(deferred);
+              invocations = HashMap.set(invocations, invocationId, {
+                ...pendingInvocation,
+                message: invokeMessage,
+              });
+              if (writer !== undefined) {
+                yield* sendWith(writer, invokeMessage).pipe(
+                  Effect.catchTags({
+                    ConnectionUnavailable: reportClientError,
+                    InvalidClientMessage: (error) => rejectInvocation(invocationId, error),
+                  }),
+                );
+              }
+            }
+            return yield* Deferred.await(deferred);
+          }).pipe(
+            Effect.tapError(() =>
+              Effect.sync(() => {
+                invocations = HashMap.remove(invocations, invocationId);
               }),
-            );
-          }
-          return yield* Deferred.await(deferred);
+            ),
+          );
         },
       );
 

package/src/dev-runtime/database.ts

@@ -47,6 +47,7 @@ import {
   SchemaDefinitionTypeId,
   type ValueDescriptor,
 } from "@ignotum/contracts/schema";
+import type { FileValue } from "@ignotum/contracts/schema/file";
 
 import { DevelopmentDatabase } from "./migrations.js";
 
@@ -59,6 +60,7 @@ type RuntimeDocumentValue =
   | number
   | string
   | Date
+  | FileValue
   | ReadonlyArray<RuntimeDocumentValue>
   | RuntimeObject;
 type RuntimeValue = RuntimeObject;
@@ -98,10 +100,18 @@ export interface LocalDatabaseReader {
 }
 
 export interface LocalDatabaseWriter extends LocalDatabaseReader {
-  readonly delete: (tableName: string, id: string) => Result<void, never>;
+  readonly delete: (tableName: string, id: string) => Result<void, DocumentNotFoundValue>;
   readonly insert: (tableName: string, value: RuntimeValue) => Result<GeneratedIdType, never>;
-  readonly patch: (tableName: string, id: string, value: RuntimeValue) => Result<void, never>;
-  readonly replace: (tableName: string, id: string, value: RuntimeValue) => Result<void, never>;
+  readonly patch: (
+    tableName: string,
+    id: string,
+    value: RuntimeValue,
+  ) => Result<void, DocumentNotFoundValue>;
+  readonly replace: (
+    tableName: string,
+    id: string,
+    value: RuntimeValue,
+  ) => Result<void, DocumentNotFoundValue>;
 }
 
 export interface LocalQueryContext {
@@ -722,11 +732,14 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         id: string,
         invalidations: DependencyRecorder<WriteInvalidation>,
       ) {
-        const table = yield* resolveTable(schema, tableName);
+        const table = yield* resolveTable(schema, tableName).pipe(Effect.orDie);
         const documentId = GeneratedId.make(id);
-        const stored = yield* findStored({ id, tableId: table.id });
-        const keys = Option.isSome(stored) ? yield* indexKeys(table, stored.value) : [];
-        yield* sql`DELETE FROM documents WHERE id = ${id} AND tableId = ${table.id}`;
+        const stored = yield* findStored({ id, tableId: table.id }).pipe(Effect.orDie);
+        if (Option.isNone(stored)) return yield* Effect.fail(documentNotFound(tableName, id));
+        const keys = yield* indexKeys(table, stored.value).pipe(Effect.orDie);
+        yield* sql`DELETE FROM documents WHERE id = ${id} AND tableId = ${table.id}`.pipe(
+          Effect.orDie,
+        );
         invalidations.record(
           tableDependency(table.id),
           documentDependency(table.id, documentId),
@@ -741,32 +754,35 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         value: RuntimeValue,
         invalidations: DependencyRecorder<WriteInvalidation>,
       ) {
-        const table = yield* resolveTable(schema, tableName);
+        const table = yield* resolveTable(schema, tableName).pipe(Effect.orDie);
         const documentId = GeneratedId.make(id);
-        const stored = yield* findStored({ id, tableId: table.id });
-        const oldKeys = Option.isSome(stored) ? yield* indexKeys(table, stored.value) : [];
-        let newKeys = oldKeys.slice(0, 0);
-        if (Option.isSome(stored)) {
-          const current = yield* decodeFields(table.definition, tableName, stored.value, "patch");
-          const fields = yield* encodeFields(
-            table.definition,
-            tableName,
-            { ...current, ...value },
-            "patch",
-            id,
-          );
-          const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
-          yield* sql`
-            UPDATE documents
-            SET fields = ${fields}, updatedAt = ${updatedAt}
-            WHERE id = ${id} AND tableId = ${table.id}
-          `;
-          newKeys = yield* writeIndexEntries(table, {
-            ...stored.value,
-            fields,
-            updatedAt,
-          });
-        }
+        const stored = yield* findStored({ id, tableId: table.id }).pipe(Effect.orDie);
+        if (Option.isNone(stored)) return yield* Effect.fail(documentNotFound(tableName, id));
+        const oldKeys = yield* indexKeys(table, stored.value).pipe(Effect.orDie);
+        const current = yield* decodeFields(
+          table.definition,
+          tableName,
+          stored.value,
+          "patch",
+        ).pipe(Effect.orDie);
+        const fields = yield* encodeFields(
+          table.definition,
+          tableName,
+          { ...current, ...value },
+          "patch",
+          id,
+        ).pipe(Effect.orDie);
+        const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
+        yield* sql`
+          UPDATE documents
+          SET fields = ${fields}, updatedAt = ${updatedAt}
+          WHERE id = ${id} AND tableId = ${table.id}
+        `.pipe(Effect.orDie);
+        const newKeys = yield* writeIndexEntries(table, {
+          ...stored.value,
+          fields,
+          updatedAt,
+        }).pipe(Effect.orDie);
         invalidations.record(
           tableDependency(table.id),
           documentDependency(table.id, documentId),
@@ -783,25 +799,25 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         value: RuntimeValue,
         invalidations: DependencyRecorder<WriteInvalidation>,
       ) {
-        const table = yield* resolveTable(schema, tableName);
+        const table = yield* resolveTable(schema, tableName).pipe(Effect.orDie);
         const documentId = GeneratedId.make(id);
-        const stored = yield* findStored({ id, tableId: table.id });
-        const oldKeys = Option.isSome(stored) ? yield* indexKeys(table, stored.value) : [];
-        let newKeys = oldKeys.slice(0, 0);
-        if (Option.isSome(stored)) {
-          const fields = yield* encodeFields(table.definition, tableName, value, "replace", id);
-          const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
-          yield* sql`
-            UPDATE documents
-            SET fields = ${fields}, updatedAt = ${updatedAt}
-            WHERE id = ${id} AND tableId = ${table.id}
-          `;
-          newKeys = yield* writeIndexEntries(table, {
-            ...stored.value,
-            fields,
-            updatedAt,
-          });
-        }
+        const stored = yield* findStored({ id, tableId: table.id }).pipe(Effect.orDie);
+        if (Option.isNone(stored)) return yield* Effect.fail(documentNotFound(tableName, id));
+        const oldKeys = yield* indexKeys(table, stored.value).pipe(Effect.orDie);
+        const fields = yield* encodeFields(table.definition, tableName, value, "replace", id).pipe(
+          Effect.orDie,
+        );
+        const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
+        yield* sql`
+          UPDATE documents
+          SET fields = ${fields}, updatedAt = ${updatedAt}
+          WHERE id = ${id} AND tableId = ${table.id}
+        `.pipe(Effect.orDie);
+        const newKeys = yield* writeIndexEntries(table, {
+          ...stored.value,
+          fields,
+          updatedAt,
+        }).pipe(Effect.orDie);
         invalidations.record(
           tableDependency(table.id),
           documentDependency(table.id, documentId),
@@ -994,17 +1010,13 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         return Object.freeze({
           ...reader,
           delete: (tableName: string, id: string) =>
-            resultFromEffect(
-              deleteDocument(schema, tableName, id, invalidations).pipe(Effect.orDie),
-            ),
+            resultFromEffect(deleteDocument(schema, tableName, id, invalidations)),
           insert: (tableName: string, value: RuntimeValue) =>
             resultFromEffect(insert(schema, tableName, value, invalidations).pipe(Effect.orDie)),
           patch: (tableName: string, id: string, value: RuntimeValue) =>
-            resultFromEffect(patch(schema, tableName, id, value, invalidations).pipe(Effect.orDie)),
+            resultFromEffect(patch(schema, tableName, id, value, invalidations)),
           replace: (tableName: string, id: string, value: RuntimeValue) =>
-            resultFromEffect(
-              replace(schema, tableName, id, value, invalidations).pipe(Effect.orDie),
-            ),
+            resultFromEffect(replace(schema, tableName, id, value, invalidations)),
         });
       };