ignotum 0.0.13 → 0.0.14

package/dist/runtime/types-C1iDP2Yf-BnkfBOQf.d.ts

@@ -0,0 +1,224 @@
+import { _ as fileFormats, g as FileValue, p as FileFormat, r as ErrorBrand, t as GeneratedId } from "./id-BzFHf3Wo-DGPCjgrf.js";
+import { a as ValueDescriptor, i as DescriptorField, n as PaginationPage, o as ValueDescriptorCarrier, r as DescribedValue, s as ValueFields, t as PaginationOptions } from "./pagination-CpYCaRYD-C2Rpp4Cw.js";
+import { Brand, Effect, Redacted, Schema, Struct } from "effect";
+//#region ../contracts/dist/values-DpCxdMvK.d.ts
+//#region src/schema/values.d.ts
+declare const IdTargetsTypeId: unique symbol;
+declare const UnresolvedReferencesTypeId: unique symbol;
+interface IdTargets<TableName extends string> {
+  readonly [IdTargetsTypeId]: TableName;
+}
+interface UnresolvedReferences<TableName extends string> {
+  readonly [UnresolvedReferencesTypeId]: TableName;
+}
+type IdTargetsOf<Value> = Value extends IdTargets<infer TableName> ? TableName : never;
+type UnresolvedReferencesOf<Value> = Value extends UnresolvedReferences<infer TableName> ? TableName : never;
+type WithIdTargets<Value, TableName extends string> = [TableName] extends [never] ? Value : Value & IdTargets<TableName>;
+type WithUnresolvedReferences<Value, TableName extends string> = [TableName] extends [never] ? Value : Value & UnresolvedReferences<TableName>;
+type PreserveIdMetadata<Value, Source> = WithUnresolvedReferences<WithIdTargets<Value, IdTargetsOf<Source>>, UnresolvedReferencesOf<Source>>;
+type PreserveValueMetadata<Value extends Schema.Constraint, Source> = Source extends ValueDescriptorCarrier ? DescribedValue<PreserveIdMetadata<Value, Source> & Schema.Constraint> : PreserveIdMetadata<Value, Source>;
+type IdDefinition<TableName extends string> = DescribedValue<Schema.brand<typeof GeneratedId, `ignotum/id/${TableName}`> & IdTargets<TableName>>;
+type ReferenceDefinition<TableName extends string> = IdDefinition<TableName> & UnresolvedReferences<TableName>;
+type AddedFieldValidation<Fields, AddedFields> = Extract<keyof AddedFields, keyof Fields> extends never ? readonly [] : readonly [invalidFields: never];
+type OverriddenFieldValidation<Fields, OverriddenFields> = Exclude<keyof OverriddenFields, keyof Fields> extends never ? readonly [] : readonly [invalidFields: never];
+type PartialFields<Fields extends Schema.Struct.Fields> = { readonly [FieldName in keyof Fields]: Fields[FieldName] extends Schema.Constraint ? PreserveValueMetadata<Schema.optional<Fields[FieldName]>, Fields[FieldName]> : never; };
+interface FixedObjectValidator<Fields extends Schema.Struct.Fields> extends Schema.Struct<Fields> {
+  readonly pick: <const Keys extends ReadonlyArray<keyof Fields>>(...keys: Keys) => ObjectDefinition<Pick<Fields, Keys[number]>>;
+  readonly omit: <const Keys extends ReadonlyArray<keyof Fields>>(...keys: Keys) => ObjectDefinition<Omit<Fields, Keys[number]>>;
+  readonly extend: <const AddedFields extends ValueFields>(fields: AddedFields, ...validation: AddedFieldValidation<Fields, AddedFields>) => ObjectDefinition<Struct.Assign<Fields, AddedFields>>;
+  readonly override: <const OverriddenFields extends Partial<Record<keyof Fields, DescribedValue>>>(fields: OverriddenFields, ...validation: OverriddenFieldValidation<Fields, OverriddenFields>) => ObjectDefinition<Struct.Assign<Fields, OverriddenFields>>;
+  readonly partial: () => ObjectDefinition<PartialFields<Fields>>;
+}
+type ObjectDefinition<Fields extends Schema.Struct.Fields> = DescribedValue<PreserveIdMetadata<FixedObjectValidator<Fields>, Fields[keyof Fields]>>;
+type ResolvedFields<Fields extends Schema.Struct.Fields> = { readonly [FieldName in keyof Fields]: Omit<Fields[FieldName], typeof UnresolvedReferencesTypeId>; };
+type LiteralValue = string | number | boolean;
+interface IndexDefinition<Name extends string = string, FieldNames extends readonly string[] = readonly string[]> {
+  readonly name: Name;
+  readonly fields: FieldNames;
+}
+interface IndexDefinitions {
+  readonly [indexName: string]: IndexDefinition;
+}
+type IndexScalar = boolean | Date | number | string;
+type IndexFieldName<Fields extends Schema.Struct.Fields> = { readonly [FieldName in keyof Fields & string]: Fields[FieldName]["Type"] extends IndexScalar ? FieldName : never; }[keyof Fields & string];
+type IndexFieldTuple<Fields extends Schema.Struct.Fields> = readonly [IndexFieldName<Fields>, ...ReadonlyArray<IndexFieldName<Fields>>];
+interface TableDefinition<Fields extends Schema.Struct.Fields, Indexes extends IndexDefinitions = {}> {
+  readonly _tag: "Table";
+  readonly descriptor: ValueDescriptor;
+  readonly fields: Fields;
+  readonly indexes: Indexes;
+  readonly schema: Schema.Struct<Fields>;
+  from<Previous extends DescribedValue>(previous: Previous, convert: (value: Previous["Type"]) => Schema.Struct.Type<Fields>): TableDefinition<Fields, Indexes>;
+  readonly index: <const Name extends string, const FieldNames extends IndexFieldTuple<Fields>>(name: Name extends keyof Indexes ? never : Name, fields: FieldNames) => TableDefinition<Fields, Indexes & Record<Name, IndexDefinition<Name, FieldNames>>>;
+}
+interface TableDefinitions {
+  readonly [tableName: string]: TableDefinition<Schema.Struct.Fields, IndexDefinitions>;
+}
+type TableNameOf$1<Definition extends TableDefinitions> = keyof Definition & string;
+type ReservedFieldName = "createdAt" | "id" | "updatedAt";
+type ReservedErrorTagName = "InternalServerError";
+declare const ReservedFieldTypeId: unique symbol;
+interface ReservedField<FieldName extends string> {
+  readonly [ReservedFieldTypeId]: `The field name '${FieldName}' is reserved by Ignotum`;
+}
+declare const ReservedErrorTagTypeId: unique symbol;
+interface ReservedErrorTag<Tag extends string> {
+  readonly [ReservedErrorTagTypeId]: `The error tag '${Tag}' is reserved by Ignotum`;
+}
+type ErrorTagValidation<Tag extends string> = Tag extends ReservedErrorTagName ? ReservedErrorTag<Tag> : unknown;
+type ReservedFieldValidation<Fields extends Schema.Struct.Fields> = { readonly [FieldName in Extract<keyof Fields, ReservedFieldName>]: ReservedField<FieldName>; };
+type ReservedErrorFieldValidation<Fields extends Schema.Struct.Fields> = { readonly [FieldName in Extract<keyof Fields, "_tag">]: ReservedField<FieldName>; };
+type ErrorDefinition<Tag extends string, Fields extends Schema.Struct.Fields> = DescribedValue<PreserveIdMetadata<Schema.brand<Schema.TaggedStruct<Tag, Fields>, typeof ErrorBrand> & ((fields: Schema.Struct.MakeIn<Fields>) => Schema.brand<Schema.TaggedStruct<Tag, Fields>, typeof ErrorBrand>["Type"]), Fields[keyof Fields]>>;
+declare const table: <const Fields extends ValueFields>(fields: Fields & ReservedFieldValidation<NoInfer<Fields>>) => TableDefinition<Fields>;
+declare const string: () => DescribedValue<Schema.String>;
+declare const number: () => DescribedValue<Schema.Finite>;
+declare const integer: () => DescribedValue<Schema.Int>;
+declare const boolean: () => DescribedValue<Schema.Boolean>;
+declare const date: () => DescribedValue<Schema.DateFromMillis>;
+interface FileOptions<Formats extends readonly FileFormat[]> {
+  readonly formats?: Formats;
+  readonly maxBytes?: number;
+}
+declare const file: <const Formats extends readonly FileFormat[] = typeof fileFormats>(options?: FileOptions<Formats>) => DescribedValue<Schema.decodeTo<Schema.declare<FileValue<"avif" | "gif" | "jpeg" | "png" | "webp">, FileValue<"avif" | "gif" | "jpeg" | "png" | "webp">>, Schema.Struct<{
+  readonly $ignotum: Schema.Literal<"file">;
+  readonly id: Schema.brand<Schema.String, "ignotum/file/FileId"> & {
+    readonly idPrefix: "file";
+  };
+  readonly format: Schema.Literals<readonly ["jpeg", "png", "webp", "avif", "gif"]>;
+  readonly name: Schema.String;
+  readonly size: Schema.Int;
+}>, never, never>> & Schema.Schema<FileValue<Formats[number]>>;
+declare const never: () => DescribedValue<Schema.Never>;
+declare const nullValue: () => DescribedValue<Schema.Null>;
+declare const literal: <const Value extends LiteralValue>(value: Value) => DescribedValue<Schema.Literal<Value>>;
+declare const literals: <const Members extends readonly [LiteralValue, LiteralValue, ...ReadonlyArray<LiteralValue>]>(...members: Members) => DescribedValue<Schema.Literals<Members>>;
+declare const userId: () => DescribedValue<Schema.brand<Schema.String, "ignotum/id/UserId">>;
+declare const id: <const TableName extends string>(tableName: TableName) => ReferenceDefinition<TableName>;
+declare const array: <Value extends DescribedValue>(value: Value) => PreserveValueMetadata<Schema.$Array<Value>, Value>;
+declare const object: <const Fields extends ValueFields>(fields: Fields) => ObjectDefinition<Fields>;
+declare const optional: <Value extends DescribedValue>(value: Value) => PreserveValueMetadata<Schema.optional<Value>, Value>;
+declare const nullable: <Value extends DescribedValue>(value: Value) => PreserveValueMetadata<Schema.NullOr<Value>, Value>;
+declare const record: <Value extends DescribedValue>(value: Value) => PreserveValueMetadata<Schema.$Record<Schema.String, Value>, Value>;
+declare const union: <const Members extends ReadonlyArray<DescribedValue>>(...members: Members) => PreserveValueMetadata<Schema.Union<Members>, Members[number]>;
+type Secret<Value> = Redacted.Redacted<Value>;
+declare const Secret: {
+  readonly isSecret: (u: unknown) => u is Redacted.Redacted<unknown>;
+  readonly value: <T>(self: Redacted.Redacted<T>) => T;
+};
+type SecretDefinition<Value extends DescribedValue> = DescribedValue<Schema.RedactedFromValue<Value>>;
+declare function secret(): SecretDefinition<ReturnType<typeof string>>;
+declare function secret<Value extends DescribedValue>(value: Value): SecretDefinition<Value>;
+declare const pagination: () => ObjectDefinition<{
+  readonly cursor: DescribedValue<Schema.NullOr<DescribedValue<Schema.brand<Schema.String, "ignotum/runtime/PaginationCursor">>> & Schema.Constraint>;
+  readonly pageSize: DescribedValue<Schema.brand<Schema.Int, "ignotum/runtime/PaginationPageSize">>;
+}>;
+declare const page: <Value extends DescribedValue>(value: Value) => ObjectDefinition<{
+  readonly items: PreserveValueMetadata<Schema.$Array<Value>, Value>;
+  readonly nextCursor: DescribedValue<Schema.NullOr<DescribedValue<Schema.brand<Schema.String, "ignotum/runtime/PaginationCursor">>> & Schema.Constraint>;
+}> & Schema.Schema<PaginationPage<Value["Type"]>>;
+declare const error: <const Tag extends string, const Fields extends ValueFields>(tag: Tag & ErrorTagValidation<Tag>, fields: Fields & ReservedErrorFieldValidation<NoInfer<Fields>>) => ErrorDefinition<Tag, Fields>;
+declare const values: {
+  userId: typeof userId;
+  array: typeof array;
+  boolean: typeof boolean;
+  date: typeof date;
+  file: typeof file;
+  error: typeof error;
+  id: typeof id;
+  integer: typeof integer;
+  literal: typeof literal;
+  literals: typeof literals;
+  never: typeof never;
+  null: typeof nullValue;
+  nullable: typeof nullable;
+  number: typeof number;
+  object: typeof object;
+  optional: typeof optional;
+  record: typeof record;
+  string: typeof string;
+  union: typeof union;
+};
+declare const environmentValues: {
+  array: typeof array;
+  boolean: typeof boolean;
+  date: typeof date;
+  integer: typeof integer;
+  literal: typeof literal;
+  literals: typeof literals;
+  never: typeof never;
+  null: typeof nullValue;
+  nullable: typeof nullable;
+  number: typeof number;
+  object: typeof object;
+  optional: typeof optional;
+  record: typeof record;
+  secret: typeof secret;
+  string: typeof string;
+  union: typeof union;
+};
+type EnvironmentValues = typeof environmentValues;
+type DocumentDefinition<Definition extends TableDefinitions, TableName extends TableNameOf$1<Definition>> = ObjectDefinition<Struct.Assign<ResolvedFields<Definition[TableName]["fields"]>, {
+  readonly id: IdDefinition<TableName>;
+  readonly createdAt: typeof Schema.DateFromMillis;
+  readonly updatedAt: typeof Schema.DateFromMillis;
+}>>;
+type BoundValues<Definition extends TableDefinitions> = Omit<typeof values, "id"> & {
+  readonly doc: <const TableName extends TableNameOf$1<Definition>>(tableName: TableName) => DocumentDefinition<Definition, TableName>;
+  readonly id: <const TableName extends TableNameOf$1<Definition>>(tableName: TableName) => IdDefinition<TableName>;
+  readonly page: typeof page;
+  readonly pagination: () => ReturnType<typeof pagination> & Schema.Schema<PaginationOptions>;
+};
+//#endregion
+//#region ../contracts/dist/types-C1iDP2Yf.d.ts
+//#region src/schema/environment.d.ts
+declare const EnvironmentDefinitionTypeId: unique symbol;
+declare const EnvironmentDecoderTypeId: unique symbol;
+type EnvironmentFields = {
+  readonly [fieldName: PropertyKey]: DescribedValue<Schema.ConstraintDecoder<unknown, never>>;
+};
+interface DefinedEnv<Fields extends EnvironmentFields = EnvironmentFields> {
+  readonly _tag: "Environment";
+  readonly fields: Fields;
+  readonly descriptors: ReadonlyArray<DescriptorField>;
+  readonly schema: Schema.Struct<Fields>;
+  readonly [EnvironmentDefinitionTypeId]: Fields;
+  readonly [EnvironmentDecoderTypeId]: (raw: Readonly<Record<string, string>>) => Effect.Effect<Readonly<EnvironmentType<DefinedEnv<Fields>>>, EnvironmentValueInvalid>;
+}
+interface EnvironmentAuthoring {
+  readonly values: EnvironmentValues;
+}
+type EnvironmentType<Environment extends DefinedEnv> = Schema.Struct.Type<Environment[typeof EnvironmentDefinitionTypeId]>;
+declare const EnvironmentValueInvalid_base: Schema.Class<EnvironmentValueInvalid, Schema.TaggedStruct<"EnvironmentValueInvalid", {
+  readonly key: Schema.optional<Schema.String>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class EnvironmentValueInvalid extends EnvironmentValueInvalid_base {}
+declare const defineEnv: <const Fields extends EnvironmentFields>(define: (authoring: EnvironmentAuthoring) => Fields) => DefinedEnv<Fields>;
+declare const emptyEnv: DefinedEnv<{}>;
+//#endregion
+//#region src/schema/types.d.ts
+/** A document identifier branded with the table it belongs to. */
+type Id<TableName extends string> = GeneratedId & Brand.Brand<`ignotum/id/${TableName}`>;
+declare const SchemaDefinitionTypeId: unique symbol;
+interface SchemaDefinitionContract<Definition> {
+  readonly [SchemaDefinitionTypeId]: Definition;
+}
+type SchemaDefinitionOf<SchemaDefinition> = SchemaDefinition extends SchemaDefinitionContract<infer Definition> ? Definition : never;
+interface TableDefinitionLike {
+  readonly fields: Schema.Struct.Fields;
+}
+interface TablesLike {
+  readonly [tableName: string]: TableDefinitionLike;
+}
+type TableNameOf<Definition extends TablesLike> = keyof Definition & string;
+interface SystemFields<TableName extends string> {
+  readonly id: Id<TableName>;
+  readonly createdAt: Date;
+  readonly updatedAt: Date;
+}
+type DocumentFields<TableName extends string, Table extends TableDefinitionLike> = SystemFields<TableName> & Schema.Struct.Type<Table["fields"]>;
+/** The complete document returned for a table, including Ignotum system fields. */
+type Document<Definition extends TablesLike, TableName extends TableNameOf<Definition>> = { readonly [FieldName in keyof DocumentFields<TableName, Definition[TableName]>]: DocumentFields<TableName, Definition[TableName]>[FieldName]; };
+//#endregion
+export { table as _, Id as a, SchemaDefinitionTypeId as c, BoundValues as d, IdTargetsOf as f, UnresolvedReferencesTypeId as g, TableDefinition as h, EnvironmentType as i, defineEnv as l, Secret as m, Document as n, SchemaDefinitionContract as o, IndexDefinitions as p, EnvironmentAuthoring as r, SchemaDefinitionOf as s, DefinedEnv as t, emptyEnv as u, values as v };
+//# sourceMappingURL=types-C1iDP2Yf-BnkfBOQf.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ignotum",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "Ignotum is an opinionated TypeScript application cloud.",
   "author": "Johannes Schießl",
   "repository": {
@@ -81,8 +81,8 @@
     "@effect/sql-sqlite-node": "4.0.0-rc.111",
     "redis": "6.2.1",
     "@ignotum/contracts": "1.0.0",
-    "@ignotum/deployment": "1.0.0",
     "@ignotum/runtime": "1.0.0",
+    "@ignotum/deployment": "1.0.0",
     "@ignotum/shared": "1.0.0"
   },
   "engines": {

package/src/cli/agent-files.ts

@@ -8,6 +8,7 @@ import appEntry from "../../../../docs/user/app-entry.md?raw";
 import cli from "../../../../docs/user/cli.md?raw";
 import database from "../../../../docs/user/database.md?raw";
 import deployApp from "../../../../docs/user/deploy-app.md?raw";
+import consoleGuide from "../../../../docs/user/console.md?raw";
 import deploymentModel from "../../../../docs/user/deployment-model.md?raw";
 import deployments from "../../../../docs/user/deployments.md?raw";
 import errors from "../../../../docs/user/errors.md?raw";
@@ -21,6 +22,7 @@ import index from "../../../../docs/user/index.md?raw";
 import indexes from "../../../../docs/user/indexes.md?raw";
 import limits from "../../../../docs/user/limits.md?raw";
 import localDevelopment from "../../../../docs/user/local-development.md?raw";
+import migrations from "../../../../docs/user/migrations.md?raw";
 import mutations from "../../../../docs/user/mutations.md?raw";
 import pagination from "../../../../docs/user/pagination.md?raw";
 import preact from "../../../../docs/user/preact.md?raw";
@@ -49,6 +51,7 @@ const references = [
   ["cli.md", cli],
   ["database.md", database],
   ["deploy-app.md", deployApp],
+  ["console.md", consoleGuide],
   ["deployment-model.md", deploymentModel],
   ["deployments.md", deployments],
   ["errors.md", errors],
@@ -62,6 +65,7 @@ const references = [
   ["indexes.md", indexes],
   ["limits.md", limits],
   ["local-development.md", localDevelopment],
+  ["migrations.md", migrations],
   ["mutations.md", mutations],
   ["pagination.md", pagination],
   ["preact.md", preact],

package/src/cli/build/server.ts

@@ -513,16 +513,28 @@ const discoverServerFunctions = Effect.fn("Deploy.discoverServerFunctionsIsolate
   );
 });
 
-const serverFunctionEntryPlugin = (definition: DiscoveredServerFunction): Plugin => {
+const serverFunctionEntryPlugin = (
+  definition: DiscoveredServerFunction,
+  schemaPath?: string,
+): Plugin => {
   const entryId = `virtual:ignotum/server-function/${definition.address}`;
   const resolvedEntryId = `\0${entryId}`;
-  const source = `import { call } from ${encodeJavaScriptString(hostModuleId)}
+  const source =
+    schemaPath === undefined
+      ? `import { call } from ${encodeJavaScriptString(hostModuleId)}
 import { invoke } from "ignotum/internal/host"
 import { ${definition.exportName} as definition } from ${encodeJavaScriptString(normalizePath(definition.modulePath))}
 
 export default async function handler(encodedRequest, encodedEnvironment) {
   return invoke(definition, JSON.parse(encodedRequest), call, JSON.parse(encodedEnvironment))
 }
+`
+      : `import { evolve } from "ignotum/internal/host"
+import schema from ${encodeJavaScriptString(normalizePath(schemaPath))}
+
+export default function handler(encodedRequest) {
+  return evolve(schema, encodedRequest)
+}
 `;
 
   return {
@@ -537,6 +549,7 @@ const buildServerFunction = Effect.fn("Deploy.buildServerFunction")(function* (
   serverOutputDirectory: string,
   conditions: ReadonlyArray<string>,
   definition: DiscoveredServerFunction,
+  schemaPath?: string,
 ) {
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
@@ -573,7 +586,7 @@ const buildServerFunction = Effect.fn("Deploy.buildServerFunction")(function* (
     configFile: false,
     logLevel: "warn",
     mode: "production",
-    plugins: [boundaries, serverFunctionEntryPlugin(definition)],
+    plugins: [boundaries, serverFunctionEntryPlugin(definition, schemaPath)],
     publicDir: false,
     resolve: {
       conditions: [...conditions],
@@ -599,8 +612,9 @@ const buildServerFunction = Effect.fn("Deploy.buildServerFunction")(function* (
   }
   if (
     entry.dynamicImports.length > 0 ||
-    entry.imports.length !== 1 ||
-    entry.imports[0] !== hostModuleId ||
+    (schemaPath === undefined
+      ? entry.imports.length !== 1 || entry.imports[0] !== hostModuleId
+      : entry.imports.length !== 0) ||
     !entry.exports.includes("default")
   ) {
     return yield* InvalidBuildOutput.make({
@@ -667,8 +681,23 @@ export const buildServer = Effect.fn("Deploy.buildServer")(function* (
     (definition) => buildServerFunction(appDirectory, outputDirectory, conditions, definition),
     { concurrency: 4 },
   );
+  const schemaPath = path.join(appDirectory, "server", "schema.ts");
+  const schemaEvolution = yield* buildServerFunction(
+    appDirectory,
+    outputDirectory,
+    conditions,
+    {
+      address: FunctionAddress.make("api._schema.evolve"),
+      exportName: "evolve",
+      kind: "Mutation",
+      moduleName: "_schema",
+      modulePath: schemaPath,
+    },
+    schemaPath,
+  );
   const manifest = {
-    formatVersion: 3,
+    formatVersion: 4,
+    schemaEvolution: { bundle: schemaEvolution.bundle, sourceMap: schemaEvolution.sourceMap },
     environment: {
       artifact: yield* artifactReference(serverEnvironmentPath, environmentBytes),
       fields: discovered.environment.fields,

package/src/cli/command.ts

@@ -13,7 +13,8 @@ import {
   status as readAuthStatus,
 } from "./auth-client.js";
 import { ControlClient } from "./control-client.js";
-import { deploy as runDeploy } from "./deploy.js";
+import { deploy as runDeploy, resumeDeployment } from "./deploy.js";
+import { DeploymentId } from "@ignotum/contracts/runtime/identity";
 import { resetDevDatabase } from "../dev-runtime/dev-database.js";
 import { dev as runDev } from "./dev.js";
 import { createApp } from "./new-app.js";
@@ -144,15 +145,37 @@ const dev = Command.make(
 const deploy = Command.make(
   "deploy",
   {
+    resume: Flag.string("resume").pipe(
+      Flag.withDescription("Finish activation of an already uploaded deployment."),
+      Flag.withSchema(DeploymentId),
+      Flag.optional,
+    ),
     app: Flag.string("app").pipe(
       Flag.withDescription("Create or link this app slug on the first deploy."),
       Flag.withSchema(AppSlug),
       Flag.optional,
     ),
   },
-  Effect.fn("deploy")(function* ({ app }) {
+  Effect.fn("deploy")(function* ({ app, resume }) {
     const path = yield* Path.Path;
     const terminal = yield* Terminal.Terminal;
+    if (Option.isSome(resume)) {
+      const result = yield* resumeDeployment(
+        path.resolve("."),
+        resume.value,
+        Option.getOrUndefined(app),
+      ).pipe(
+        // @effect-diagnostics-next-line strictEffectProvide:off This command owns the authenticated control client.
+        Effect.provide(ControlClient.layer),
+        Effect.mapError((error) =>
+          CliError.UserError.make({ cause: error, userMessage: error.message }),
+        ),
+      );
+      yield* terminal.display(
+        `Deployment activated.\n\nApp: ${result.appUrl}\nDeployment: ${result.deploymentId}\n`,
+      );
+      return;
+    }
     const result = yield* runDeploy(path.resolve("."), Option.getOrUndefined(app)).pipe(
       // @effect-diagnostics-next-line strictEffectProvide:off The deploy subcommand owns this client layer for its full lifetime.
       Effect.provide(ControlClient.layer),

package/src/cli/deploy.ts

@@ -15,7 +15,12 @@ import { appUrl, configureApp, type AppConfiguration } from "./app-configuration
 import { buildClient } from "./build/client.js";
 import { buildServer } from "./build/server.js";
 import { generate } from "./codegen.js";
-import { ControlClient, deploymentUploadFiles } from "./control-client.js";
+import {
+  ControlClient,
+  deploymentUploadFiles,
+  type ControlApiError,
+  type ControlClientUnavailable,
+} from "./control-client.js";
 
 export interface DeploymentBuildResult {
   readonly clientAssets: number;
@@ -58,6 +63,18 @@ export class DeploymentActivationUnconfirmed extends Schema.TaggedError<Deployme
   },
 ) {}
 
+const activationError = (
+  deploymentId: DeploymentId,
+  cause: ControlApiError | ControlClientUnavailable,
+) =>
+  cause._tag === "ControlClientUnavailable" || cause.status >= 500
+    ? DeploymentActivationUnconfirmed.make({
+        cause,
+        deploymentId,
+        message: `Deployment ${deploymentId} is ready, but activation could not be confirmed. Run ignotum deploy --resume ${deploymentId} to finish activation.`,
+      })
+    : cause;
+
 const replaceBuildDirectory = Effect.fn("Deploy.replaceBuildDirectory")(function* (
   stateDirectory: string,
   stagingDirectory: string,
@@ -192,16 +209,9 @@ export const uploadDeployment = Effect.fn("Deploy.upload")(function* (
     }),
   );
 
-  yield* control.activateDeployment(configuration.appId, deployment.id).pipe(
-    Effect.catchTags({
-      ControlClientUnavailable: (cause) =>
-        DeploymentActivationUnconfirmed.make({
-          cause,
-          deploymentId: deployment.id,
-          message: `Deployment ${deployment.id} is ready, but activation could not be confirmed.`,
-        }),
-    }),
-  );
+  yield* control
+    .activateDeployment(configuration.appId, deployment.id)
+    .pipe(Effect.mapError((cause) => activationError(deployment.id, cause)));
 
   return deployment.id;
 });
@@ -220,3 +230,16 @@ export const deploy = Effect.fn("Deploy.run")(function* (
     deploymentId,
   } satisfies DeployResult;
 });
+
+export const resumeDeployment = Effect.fn("Deploy.resume")(function* (
+  appDirectory: string,
+  deploymentId: DeploymentId,
+  requestedSlug?: AppSlug,
+) {
+  const configuration = yield* configureApp(appDirectory, requestedSlug);
+  const control = yield* ControlClient;
+  yield* control
+    .activateDeployment(configuration.appId, deploymentId)
+    .pipe(Effect.mapError((cause) => activationError(deploymentId, cause)));
+  return { appUrl: appUrl(configuration.slug), deploymentId };
+});

package/src/client/sync.ts

@@ -67,7 +67,7 @@ interface QueryEntry {
   result: QueryResult<unknown, ErrorValue> | ClientInfrastructureError;
 }
 
-interface QueryObserver {
+export interface QueryObserver {
   readonly getSnapshot: () => QueryResult<unknown, ErrorValue> | ClientInfrastructureError;
   readonly release: Effect.Effect<void>;
   readonly subscribe: (listener: Listener) => () => void;

package/src/dev-runtime/database.ts

@@ -43,10 +43,15 @@ import type {
   RuntimeTableDefinition,
 } from "@ignotum/contracts/runtime/schema";
 import {
+  applyValueDefaults,
+  descriptorFields,
+  evolveStoredFields,
   getValueDescriptor,
   SchemaDefinitionTypeId,
   type ValueDescriptor,
 } from "@ignotum/contracts/schema";
+import { SchemaSnapshot } from "@ignotum/contracts/deployment";
+import { encodeCanonical } from "@ignotum/deployment";
 import type { FileValue } from "@ignotum/contracts/schema/file";
 
 import { DevelopmentDatabase } from "./migrations.js";
@@ -272,9 +277,13 @@ const encodeFields = Effect.fn("LocalDatabase.encodeFields")(function* (
   operation: Extract<DatabaseOperation, "insert" | "patch" | "replace">,
   id: string | null,
 ) {
-  return yield* Schema.encodeEffect(fieldsCodec(table), {
+  const normalized = yield* Effect.try({
+    try: () => (operation === "patch" ? value : applyValueDefaults(table.schema, value)),
+    catch: (cause) => schemaMismatch(tableName, id, operation, cause),
+  });
+  return yield* Schema.encodeUnknownEffect(fieldsCodec(table), {
     onExcessProperty: "error",
-  })(value).pipe(Effect.mapError((cause) => schemaMismatch(tableName, id, operation, cause)));
+  })(normalized).pipe(Effect.mapError((cause) => schemaMismatch(tableName, id, operation, cause)));
 });
 
 const decodeFields = Effect.fn("LocalDatabase.decodeFields")(function* (
@@ -492,6 +501,70 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         }
       });
 
+      const prepareSchema = Effect.fn("LocalDatabase.prepareSchema")(function* (
+        schema: RuntimeSchemaDefinition,
+      ) {
+        const definitions = schema[SchemaDefinitionTypeId];
+        const snapshot = encodeCanonical(SchemaSnapshot, {
+          formatVersion: 2,
+          tables: Object.entries(definitions)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([name, definition]) => ({
+              name,
+              fields: descriptorFields(definition.fields),
+              indexes: Object.values(definition.indexes).sort((left, right) =>
+                left.name.localeCompare(right.name),
+              ),
+            })),
+        });
+        const current = yield* sql<{
+          snapshot: string;
+        }>`SELECT snapshot FROM schema_state WHERE singleton = 1`;
+        if (current[0]?.snapshot === snapshot) return;
+        let changedData = false;
+        const storedTables = yield* sql<{ id: string; name: string }>`SELECT id, name FROM tables`;
+        for (const stored of storedTables) {
+          if (Object.hasOwn(definitions, stored.name)) continue;
+          const documents =
+            yield* sql`SELECT 1 FROM documents WHERE tableId = ${stored.id} LIMIT 1`;
+          if (documents.length > 0)
+            return yield* Effect.die(`Cannot remove non-empty table '${stored.name}'.`);
+          yield* sql`DELETE FROM tables WHERE id = ${stored.id}`;
+        }
+        for (const [name, definition] of Object.entries(definitions)) {
+          const table = yield* resolveTable(schema, name);
+          let cursor = "";
+          let changed = false;
+          while (true) {
+            const rows = yield* sql<{ id: string; fields: string }>`
+              SELECT id, fields FROM documents WHERE tableId = ${table.id} AND id > ${cursor}
+              ORDER BY id LIMIT 100
+            `;
+            if (rows.length === 0) break;
+            for (const row of rows) {
+              const fields = yield* Effect.try({
+                try: () =>
+                  JSON.stringify(evolveStoredFields(definition.schema, JSON.parse(row.fields))),
+                catch: () =>
+                  new Error(
+                    `Document '${row.id}' in '${name}' does not match the new schema or its conversion rules.`,
+                  ),
+              }).pipe(Effect.orDie);
+              if (fields !== row.fields) {
+                yield* sql`UPDATE documents SET fields = ${fields} WHERE tableId = ${table.id} AND id = ${row.id}`;
+                changed = true;
+                changedData = true;
+              }
+              cursor = row.id;
+            }
+          }
+          if (changed) yield* sql`DELETE FROM indexes WHERE tableId = ${table.id}`;
+        }
+        yield* sql`INSERT INTO schema_state (singleton, snapshot) VALUES (1, ${snapshot})
+          ON CONFLICT (singleton) DO UPDATE SET snapshot = excluded.snapshot`;
+        if (current.length > 0 || changedData) yield* advanceRevision(undefined);
+      });
+
       const indexKeys = Effect.fn("LocalDatabase.indexKeys")(function* (
         table: ResolvedTable,
         row: StoredDocument,
@@ -1026,6 +1099,7 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
       ) =>
         sql.withTransaction(
           Effect.gen(function* () {
+            yield* prepareSchema(schema).pipe(Effect.orDie);
             yield* prepareIndexes(schema).pipe(Effect.orDie);
             const dependencies = makeDependencyRecorder<ReadDependency>();
             const context = Object.freeze({
@@ -1044,6 +1118,7 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
       ) =>
         sql.withTransaction(
           Effect.gen(function* () {
+            yield* prepareSchema(schema).pipe(Effect.orDie);
             yield* prepareIndexes(schema).pipe(Effect.orDie);
             const invalidations = makeDependencyRecorder<WriteInvalidation>();
             const context = Object.freeze({

package/src/dev-runtime/id.ts

@@ -1,4 +1,14 @@
-import { Context, Effect, FileSystem, Layer, Path, Schema, Semaphore } from "effect";
+import {
+  Context,
+  Effect,
+  FileSystem,
+  Layer,
+  Path,
+  Predicate,
+  Record,
+  Schema,
+  Semaphore,
+} from "effect";
 import {
   DevelopmentUsername,
   developmentSelectionKey,
@@ -31,9 +41,14 @@ export const LocalCompletion = Schema.Struct({
 
 const projection = (user: User, share: ReadonlyArray<string>): User => ({
   id: user.id,
-  name: share.includes("name") ? user.name : undefined,
-  email: share.includes("email") ? user.email : undefined,
-  image: share.includes("image") ? user.image : undefined,
+  ...Record.filter(
+    {
+      name: share.includes("name") ? user.name : undefined,
+      email: share.includes("email") ? user.email : undefined,
+      image: share.includes("image") ? user.image : undefined,
+    },
+    Predicate.isNotUndefined,
+  ),
 });
 
 export class LocalId extends Context.Service<

package/src/dev-runtime/migrations.ts

@@ -88,10 +88,19 @@ const addApplicationFiles = Effect.gen(function* () {
   `;
 });
 
+const addSchemaState = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`CREATE TABLE schema_state (
+    singleton INTEGER PRIMARY KEY NOT NULL CHECK (singleton = 1),
+    snapshot TEXT NOT NULL CHECK (json_valid(snapshot))
+  ) STRICT`;
+});
+
 export const developmentMigrationLoader = Migrator.fromRecord({
   "0001_initial_development_schema": initialDevelopmentSchema,
   "0002_application_indexes": addDevelopmentIndexes,
   "0003_application_files": addApplicationFiles,
+  "0004_schema_state": addSchemaState,
 });
 
 interface DevelopmentDatabaseService {