ignotum 0.0.14 → 0.0.16

package/src/cli/build/server.ts

@@ -3,31 +3,12 @@ import process from "node:process";
 import { fileURLToPath } from "node:url";
 
 import * as Config from "effect/Config";
-import {
-  Array,
-  Crypto,
-  Effect,
-  Encoding,
-  FileSystem,
-  Path,
-  Predicate,
-  Schema,
-  Stream,
-  String,
-} from "effect";
+import { Array, Effect, FileSystem, Path, Predicate, Schema, Stream, String } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 import { createServer, defaultServerConditions, normalizePath } from "vite";
-import type { Plugin, ViteDevServer } from "vite";
+import type { ViteDevServer } from "vite";
 
-import {
-  ServerBuildManifest,
-  SchemaSnapshot,
-  SchemaSnapshotField,
-  EnvironmentArtifact,
-  schemaSnapshotPath,
-  serverEnvironmentPath,
-  type ServerFunctionArtifact,
-} from "@ignotum/contracts/deployment";
+import { SchemaSnapshot, SchemaSnapshotField } from "@ignotum/contracts/version";
 import { FunctionAddress } from "@ignotum/contracts/runtime/sync";
 import type { FunctionKind } from "@ignotum/contracts/runtime/functions";
 import {
@@ -38,31 +19,19 @@ import {
   isDefinedEnv,
   isDefinedSchema,
   ValueDescriptor,
+  evolutionRules,
+  SchemaDefinitionTypeId,
   type DefinedSchema,
   type Tables,
 } from "@ignotum/contracts/schema";
-import {
-  artifactReference,
-  encodeCanonical,
-  encodeSchemaSnapshot,
-  makeSchemaSnapshot,
-  utf8Bytes,
-} from "@ignotum/deployment";
+import { encodeCanonical, makeSchemaSnapshot } from "@ignotum/versions";
 
 import { inspectRuntimeFunctionDefinition } from "../../internal/function-definition.js";
 import { loadEnvironment } from "../environment.js";
 import { moduleBoundariesPlugin, BuildBoundaryViolation } from "../module-boundaries.js";
-import {
-  causeMessage,
-  InvalidBuildOutput,
-  runViteBuild,
-  sourceMapPathTransform,
-  ViteBuildFailed,
-  type GeneratedChunk,
-} from "./artifact.js";
+import { causeMessage, InvalidBuildOutput, ViteBuildFailed } from "./artifact.js";
 
-const hostModuleId = "ignotum:host";
-const encodeJavaScriptString = Schema.encodeSync(Schema.fromJsonString(Schema.String));
+import { compileManagedServer } from "./managed-server.js";
 
 const DiscoveredServerFunction = Schema.Struct({
   address: FunctionAddress,
@@ -85,7 +54,15 @@ interface DiscoveredServerFunction {
   readonly returns?: ValueDescriptor;
 }
 
+const DiscoveredConversion = Schema.Struct({
+  table: Schema.String,
+  field: Schema.String,
+  from: ValueDescriptor,
+  to: ValueDescriptor,
+});
+
 const ServerDiscoveryManifest = Schema.Struct({
+  conversions: Schema.Array(DiscoveredConversion),
   environment: Schema.Struct({
     fields: Schema.Array(SchemaSnapshotField),
     hasDefinition: Schema.Boolean,
@@ -94,19 +71,10 @@ const ServerDiscoveryManifest = Schema.Struct({
   functions: Schema.Array(DiscoveredServerFunction),
   schema: SchemaSnapshot,
 });
-type ServerDiscoveryManifest = typeof ServerDiscoveryManifest.Type;
+export type ServerDiscoveryManifest = typeof ServerDiscoveryManifest.Type;
 const ServerDiscoveryManifestJson = Schema.fromJsonString(ServerDiscoveryManifest);
 const ServerModuleNamesJson = Schema.fromJsonString(Schema.Array(Schema.String));
 
-export interface ServerBuildResult {
-  readonly environment: {
-    readonly bytes: Uint8Array;
-    readonly path: typeof serverEnvironmentPath;
-  };
-  readonly functions: number;
-  readonly manifestPath: string;
-}
-
 export class ServerFunctionDiscoveryFailed extends Schema.TaggedError<ServerFunctionDiscoveryFailed>()(
   "ServerFunctionDiscoveryFailed",
   {
@@ -160,6 +128,7 @@ const acquireModuleRunner = Effect.fn("Deploy.acquireServerModuleRunner")(functi
           },
           root: appDirectory,
           server: {
+            hmr: false,
             forwardConsole: false,
             middlewareMode: true,
             fs: { strict: true, allow: [appDirectory] },
@@ -397,7 +366,34 @@ export const runServerDiscoveryWorker = Effect.fn("Deploy.runServerDiscoveryWork
         message: "The application schema does not have canonical Ignotum descriptors.",
       }),
   });
+  const conversions: Array<typeof DiscoveredConversion.Type> = [];
+  const visit = (table: string, field: string, value: Schema.Constraint): void => {
+    const rules = evolutionRules(value);
+    const to = getValueDescriptor(value);
+    for (const previous of rules.previous ?? []) {
+      const from = getValueDescriptor(previous.schema);
+      if (from !== undefined && to !== undefined) conversions.push({ table, field, from, to });
+      visit(table, field, previous.schema);
+    }
+    const children = rules.children;
+    if (children?.type === "object") {
+      for (const child of Object.values(children.fields)) visit(table, field, child);
+    } else if (children?.type === "union") {
+      for (const child of children.members) visit(table, field, child);
+    } else if (children !== undefined) visit(table, field, children.value);
+  };
+  for (const [table, definition] of Object.entries(discovered.schema[SchemaDefinitionTypeId])) {
+    for (const [field, value] of Object.entries(definition.fields)) visit(table, field, value);
+  }
   return yield* Schema.encodeEffect(ServerDiscoveryManifestJson)({
+    conversions: [
+      ...new Map(
+        conversions.map((conversion) => [
+          encodeCanonical(DiscoveredConversion, conversion),
+          conversion,
+        ]),
+      ).values(),
+    ],
     environment: discovered.environment,
     functions: discovered.functions,
     schema,
@@ -513,210 +509,16 @@ const discoverServerFunctions = Effect.fn("Deploy.discoverServerFunctionsIsolate
   );
 });
 
-const serverFunctionEntryPlugin = (
-  definition: DiscoveredServerFunction,
-  schemaPath?: string,
-): Plugin => {
-  const entryId = `virtual:ignotum/server-function/${definition.address}`;
-  const resolvedEntryId = `\0${entryId}`;
-  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 {
-    name: "ignotum:server-function-entry",
-    load: (id) => (id === resolvedEntryId ? source : undefined),
-    resolveId: (id) => (id === entryId ? resolvedEntryId : undefined),
-  };
-};
-
-const buildServerFunction = Effect.fn("Deploy.buildServerFunction")(function* (
-  appDirectory: string,
-  serverOutputDirectory: string,
-  conditions: ReadonlyArray<string>,
-  definition: DiscoveredServerFunction,
-  schemaPath?: string,
-) {
-  const fileSystem = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const functionDirectory = path.join(serverOutputDirectory, "functions", definition.moduleName);
-  const transformSourceMapPath = yield* sourceMapPathTransform(appDirectory);
-  const boundaries = yield* moduleBoundariesPlugin("Server", appDirectory);
-  const entryId = `virtual:ignotum/server-function/${definition.address}`;
-  yield* fileSystem.makeDirectory(functionDirectory, { recursive: true });
-
-  const output = yield* runViteBuild(definition.address, {
-    build: {
-      cssCodeSplit: false,
-      emptyOutDir: false,
-      minify: "oxc",
-      modulePreload: false,
-      outDir: functionDirectory,
-      rolldownOptions: {
-        external: [hostModuleId],
-        input: entryId,
-        preserveEntrySignatures: "strict",
-        treeshake: {
-          manualPureFunctions: ["mutation", "query"],
-        },
-        output: {
-          codeSplitting: false,
-          entryFileNames: `${definition.exportName}-[hash].mjs`,
-          format: "es",
-          sourcemapPathTransform: transformSourceMapPath,
-        },
-      },
-      sourcemap: true,
-      target: "es2020",
-    },
-    configFile: false,
-    logLevel: "warn",
-    mode: "production",
-    plugins: [boundaries, serverFunctionEntryPlugin(definition, schemaPath)],
-    publicDir: false,
-    resolve: {
-      conditions: [...conditions],
-      noExternal: true,
-      tsconfigPaths: true,
-    },
-    root: appDirectory,
-  });
-  const entries = Array.filter(
-    output,
-    (item): item is GeneratedChunk => item.type === "chunk" && item.isEntry,
-  );
-  if (entries.length !== 1) {
-    return yield* InvalidBuildOutput.make({
-      message: `${definition.address} did not emit exactly one entry chunk.`,
-    });
-  }
-  const entry = entries[0];
-  if (entry === undefined) {
-    return yield* InvalidBuildOutput.make({
-      message: `${definition.address} did not emit an entry chunk.`,
-    });
-  }
-  if (
-    entry.dynamicImports.length > 0 ||
-    (schemaPath === undefined
-      ? entry.imports.length !== 1 || entry.imports[0] !== hostModuleId
-      : entry.imports.length !== 0) ||
-    !entry.exports.includes("default")
-  ) {
-    return yield* InvalidBuildOutput.make({
-      message: `${definition.address} is not a self-contained default-exported handler. Imports: ${entry.imports.join(", ") || "none"}; dynamic imports: ${entry.dynamicImports.join(", ") || "none"}; exports: ${entry.exports.join(", ") || "none"}.`,
-    });
-  }
-
-  const relativeFile = normalizePath(path.join("functions", definition.moduleName, entry.fileName));
-  const relativeSourceMap = `${relativeFile}.map`;
-  const absoluteFile = path.join(serverOutputDirectory, relativeFile);
-  const absoluteSourceMap = path.join(serverOutputDirectory, relativeSourceMap);
-  const sourceMapExists = yield* fileSystem.exists(absoluteSourceMap);
-  if (!sourceMapExists) {
-    return yield* InvalidBuildOutput.make({
-      message: `${definition.address} did not emit a source map.`,
-    });
-  }
-  const bundlePath = normalizePath(path.join("server", relativeFile));
-  const sourceMapPath = normalizePath(path.join("server", relativeSourceMap));
-
-  const artifact = {
-    address: definition.address,
-    kind: definition.kind,
-    bundle: yield* artifactReference(bundlePath, yield* fileSystem.readFile(absoluteFile)),
-    sourceMap: yield* artifactReference(
-      sourceMapPath,
-      yield* fileSystem.readFile(absoluteSourceMap),
-    ),
-  };
-  const withArgs =
-    definition.args === undefined ? artifact : { ...artifact, args: definition.args };
-  const withErrors =
-    definition.errors === undefined ? withArgs : { ...withArgs, errors: definition.errors };
-  return definition.returns === undefined
-    ? (withErrors satisfies ServerFunctionArtifact)
-    : ({ ...withErrors, returns: definition.returns } satisfies ServerFunctionArtifact);
-});
-
-export const buildServer = Effect.fn("Deploy.buildServer")(function* (
+export const buildManagedServer = Effect.fn("Deploy.buildManagedServer")(function* (
   appDirectory: string,
   outputDirectory: string,
   functionModules: ReadonlyArray<string>,
 ) {
-  const fileSystem = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const conditions = yield* serverConditions();
   const discovered = yield* discoverServerFunctions(appDirectory, functionModules);
-  const crypto = yield* Crypto.Crypto;
-  const environmentArtifact = {
-    formatVersion: 1,
-    nonce: Encoding.encodeBase64Url(yield* crypto.randomBytes(32)),
-    values: discovered.environment.values,
-  } satisfies EnvironmentArtifact;
-  const environmentBytes = utf8Bytes(
-    `${encodeCanonical(EnvironmentArtifact, environmentArtifact)}\n`,
-  );
-
-  yield* fileSystem.makeDirectory(outputDirectory, { recursive: true });
-  const encodedSnapshot = encodeSchemaSnapshot(discovered.schema);
-  const snapshotBytes = utf8Bytes(encodedSnapshot);
-  yield* fileSystem.writeFile(path.join(outputDirectory, "schema.json"), snapshotBytes);
-  const functions = yield* Effect.forEach(
-    discovered.functions,
-    (definition) => buildServerFunction(appDirectory, outputDirectory, conditions, definition),
-    { concurrency: 4 },
-  );
-  const schemaPath = path.join(appDirectory, "server", "schema.ts");
-  const schemaEvolution = yield* buildServerFunction(
+  return yield* compileManagedServer(
     appDirectory,
     outputDirectory,
-    conditions,
-    {
-      address: FunctionAddress.make("api._schema.evolve"),
-      exportName: "evolve",
-      kind: "Mutation",
-      moduleName: "_schema",
-      modulePath: schemaPath,
-    },
-    schemaPath,
+    yield* serverConditions(),
+    discovered,
   );
-  const manifest = {
-    formatVersion: 4,
-    schemaEvolution: { bundle: schemaEvolution.bundle, sourceMap: schemaEvolution.sourceMap },
-    environment: {
-      artifact: yield* artifactReference(serverEnvironmentPath, environmentBytes),
-      fields: discovered.environment.fields,
-    },
-    schema: yield* artifactReference(schemaSnapshotPath, snapshotBytes),
-    functions,
-  } satisfies ServerBuildManifest;
-  const encodedManifest = `${encodeCanonical(ServerBuildManifest, manifest)}\n`;
-  const manifestPath = path.join(outputDirectory, "manifest.json");
-  yield* fileSystem.writeFileString(manifestPath, encodedManifest);
-  yield* Schema.decodeEffect(Schema.fromJsonString(ServerBuildManifest))(encodedManifest).pipe(
-    Effect.mapError(() =>
-      InvalidBuildOutput.make({ message: "Ignotum emitted an invalid server manifest." }),
-    ),
-  );
-
-  return {
-    environment: { bytes: environmentBytes, path: serverEnvironmentPath },
-    functions: functions.length,
-    manifestPath,
-  } satisfies ServerBuildResult;
 });

package/src/cli/client-config.ts

@@ -1,29 +1,4 @@
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-
-import { Effect, FileSystem, Path, Schema } from "effect";
-import { defaultClientConditions, normalizePath } from "vite";
-import type { Alias } from "vite";
-
-const clientEntryFileName = "index.tsx";
-const clientIconFileName = "icon.svg";
-const preactSpecifiers = [
-  "preact/jsx-dev-runtime",
-  "preact/jsx-runtime",
-  "preact/devtools",
-  "preact/debug",
-  "preact/hooks",
-  "preact",
-] as const;
-const prefreshSpecifiers = ["@prefresh/core", "@prefresh/utils"] as const;
-
-export class ClientFileNotFound extends Schema.TaggedError<ClientFileNotFound>()(
-  "ClientFileNotFound",
-  {
-    message: Schema.String,
-    path: Schema.String,
-  },
-) {}
+import { Schema } from "effect";
 
 export class InvalidClientFile extends Schema.TaggedError<InvalidClientFile>()(
   "InvalidClientFile",
@@ -32,117 +7,3 @@ export class InvalidClientFile extends Schema.TaggedError<InvalidClientFile>()(
     path: Schema.String,
   },
 ) {}
-
-export class ClientRuntimeResolutionFailed extends Schema.TaggedError<ClientRuntimeResolutionFailed>()(
-  "ClientRuntimeResolutionFailed",
-  {
-    cause: Schema.Defect(),
-    message: Schema.String,
-  },
-) {}
-
-export interface ClientBuildConfig {
-  readonly aliases: ReadonlyArray<Alias>;
-  readonly conditions: ReadonlyArray<string>;
-}
-
-export interface ClientFiles {
-  readonly clientDirectory: string;
-  readonly entryPath: string;
-  readonly iconPath: string | undefined;
-}
-
-export const validateClientFiles = Effect.fn("ClientConfig.validateFiles")(function* (
-  appDirectory: string,
-) {
-  const fileSystem = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const clientDirectory = path.join(appDirectory, "client");
-  const nestedPublicDirectory = path.join(clientDirectory, "public");
-  if (yield* fileSystem.exists(nestedPublicDirectory)) {
-    return yield* InvalidClientFile.make({
-      message: `Client public files must be placed in the top-level public directory, not ${nestedPublicDirectory}.`,
-      path: nestedPublicDirectory,
-    });
-  }
-  const entryPath = path.join(clientDirectory, clientEntryFileName);
-  if (!(yield* fileSystem.exists(entryPath))) {
-    return yield* ClientFileNotFound.make({
-      message: `Required client file not found: ${entryPath}`,
-      path: entryPath,
-    });
-  }
-  const entryInfo = yield* fileSystem.stat(entryPath);
-  if (entryInfo.type !== "File") {
-    return yield* InvalidClientFile.make({
-      message: `Required client entry is not a regular file: ${entryPath}`,
-      path: entryPath,
-    });
-  }
-
-  const iconPath = path.join(clientDirectory, clientIconFileName);
-  const hasIcon = yield* fileSystem.exists(iconPath);
-  if (hasIcon) {
-    const iconInfo = yield* fileSystem.stat(iconPath);
-    if (iconInfo.type !== "File") {
-      return yield* InvalidClientFile.make({
-        message: `Optional client icon is not a regular file: ${iconPath}`,
-        path: iconPath,
-      });
-    }
-  }
-
-  return {
-    clientDirectory,
-    entryPath,
-    iconPath: hasIcon ? iconPath : undefined,
-  } satisfies ClientFiles;
-});
-
-export const resolveClientBuildConfig = Effect.fn("ClientConfig.resolve")(function* (
-  includePrefresh: boolean,
-) {
-  const fileSystem = yield* FileSystem.FileSystem;
-  const sourceClientEntry = fileURLToPath(new URL("../../src/client/index.ts", import.meta.url));
-  const sourceContractsEntry = fileURLToPath(
-    new URL("../../../contracts/src/schema/index.ts", import.meta.url),
-  );
-  const hasSourceClient = yield* fileSystem.exists(sourceClientEntry);
-  const hasSourceContracts = yield* fileSystem.exists(sourceContractsEntry);
-  const hasWorkspaceSourceExports = hasSourceClient && hasSourceContracts;
-
-  return yield* Effect.try({
-    try: (): ClientBuildConfig => {
-      const prefreshRequire = createRequire(import.meta.resolve("@prefresh/vite"));
-      const aliases: ReadonlyArray<Alias> = [
-        {
-          find: /^tailwindcss$/,
-          replacement: normalizePath(fileURLToPath(import.meta.resolve("tailwindcss/index.css"))),
-        },
-        ...preactSpecifiers.map((specifier) => ({
-          find: specifier,
-          replacement: normalizePath(fileURLToPath(import.meta.resolve(specifier))),
-        })),
-        ...(includePrefresh
-          ? prefreshSpecifiers.map((specifier) => ({
-              find: specifier,
-              replacement: normalizePath(prefreshRequire.resolve(specifier)),
-            }))
-          : []),
-      ];
-
-      return {
-        aliases,
-        conditions: [
-          ...(hasWorkspaceSourceExports ? ["@ignotum/source"] : []),
-          ...defaultClientConditions,
-        ],
-      };
-    },
-    catch: (cause) =>
-      ClientRuntimeResolutionFailed.make({
-        cause,
-        message: "Ignotum could not resolve its client runtime.",
-      }),
-  });
-});

package/src/cli/client-styles.ts

@@ -0,0 +1 @@
+export const clientStylesSource = '@import "tailwindcss";\n';

package/src/cli/codegen.ts

@@ -2,7 +2,8 @@ import { Array, Effect, FileSystem, Path, Schema, String } from "effect";
 
 import { FunctionNamePart } from "@ignotum/contracts/runtime/sync";
 
-const generatedHeader = "// Generated by `ignotum codegen`. Do not edit.";
+export const generatedHeader = "// Generated by `ignotum codegen`. Do not edit.";
+export const generatedImageTypes = '/// <reference types="ignotum/image-assets" />';
 
 export class SchemaNotFound extends Schema.TaggedError<SchemaNotFound>()("SchemaNotFound", {
   message: Schema.String,
@@ -25,7 +26,7 @@ export class GeneratedFileConflict extends Schema.TaggedError<GeneratedFileConfl
   },
 ) {}
 
-interface GeneratedOutput {
+export interface GeneratedOutput {
   readonly content: string;
   readonly path: string;
 }
@@ -99,6 +100,8 @@ const renderApi = (moduleNames: ReadonlyArray<string>): string => {
   });
   return `${generatedHeader}
 
+${generatedImageTypes}
+
 import { createApi } from "ignotum/internal/api";
 
 type Modules = {
@@ -109,7 +112,9 @@ export const api = createApi<Modules>();
 `;
 };
 
-const inspectOutput = Effect.fn("Codegen.inspectOutput")(function* (output: GeneratedOutput) {
+export const inspectOutput = Effect.fn("Codegen.inspectOutput")(function* (
+  output: GeneratedOutput,
+) {
   const fileSystem = yield* FileSystem.FileSystem;
   const exists = yield* fileSystem.exists(output.path);
 
@@ -133,7 +138,7 @@ const inspectOutput = Effect.fn("Codegen.inspectOutput")(function* (output: Gene
   return "write" as const;
 });
 
-const writeOutput = Effect.fn("Codegen.writeOutput")(function* (output: GeneratedOutput) {
+export const writeOutput = Effect.fn("Codegen.writeOutput")(function* (output: GeneratedOutput) {
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const directory = path.dirname(output.path);

package/src/cli/command.ts

@@ -5,7 +5,7 @@ import { AppSlug } from "@ignotum/contracts/control";
 import { IdGenerator } from "@ignotum/shared/id";
 
 import packageJson from "../../package.json" with { type: "json" };
-import { generate } from "./codegen.js";
+import { generateClientRoutes } from "./route-codegen.js";
 import {
   AuthCredentialStore,
   login as runLogin,
@@ -13,8 +13,8 @@ import {
   status as readAuthStatus,
 } from "./auth-client.js";
 import { ControlClient } from "./control-client.js";
-import { deploy as runDeploy, resumeDeployment } from "./deploy.js";
-import { DeploymentId } from "@ignotum/contracts/runtime/identity";
+import { deploy as runDeploy, resumeVersion } from "./deploy.js";
+import { VersionId } 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";
@@ -80,7 +80,7 @@ const codegen = Command.make(
   Effect.fn("codegen")(function* () {
     const path = yield* Path.Path;
     const terminal = yield* Terminal.Terminal;
-    const result = yield* generate(path.resolve(".")).pipe(
+    const result = yield* generateClientRoutes(path.resolve(".")).pipe(
       Effect.mapError((error) =>
         CliError.UserError.make({ cause: error, userMessage: error.message }),
       ),
@@ -146,8 +146,8 @@ const deploy = Command.make(
   "deploy",
   {
     resume: Flag.string("resume").pipe(
-      Flag.withDescription("Finish activation of an already uploaded deployment."),
-      Flag.withSchema(DeploymentId),
+      Flag.withDescription("Finish activation of an already uploaded version."),
+      Flag.withSchema(VersionId),
       Flag.optional,
     ),
     app: Flag.string("app").pipe(
@@ -160,7 +160,7 @@ const deploy = Command.make(
     const path = yield* Path.Path;
     const terminal = yield* Terminal.Terminal;
     if (Option.isSome(resume)) {
-      const result = yield* resumeDeployment(
+      const result = yield* resumeVersion(
         path.resolve("."),
         resume.value,
         Option.getOrUndefined(app),
@@ -172,7 +172,7 @@ const deploy = Command.make(
         ),
       );
       yield* terminal.display(
-        `Deployment activated.\n\nApp: ${result.appUrl}\nDeployment: ${result.deploymentId}\n`,
+        `Version ${result.versionNumber} is live.\n\nApp: ${result.appUrl}\nVersion ID: ${result.versionId}\n`,
       );
       return;
     }
@@ -185,7 +185,7 @@ const deploy = Command.make(
     );
 
     yield* terminal.display(
-      `Deployed ${result.clientAssets} client artifact${result.clientAssets === 1 ? "" : "s"} and ${result.serverFunctions} server function${result.serverFunctions === 1 ? "" : "s"}.\n\nApp: ${result.appUrl}\nDeployment: ${result.deploymentId}\n`,
+      `Version ${result.versionNumber} is live.\n\nApp: ${result.appUrl}\nVersion ID: ${result.versionId}\n`,
     );
   }),
 ).pipe(Command.withDescription("Build and deploy the application to Ignotum Cloud."));