ignotum 0.0.16 → 0.0.18

package/src/cli/command.ts

@@ -14,7 +14,6 @@ import {
 } from "./auth-client.js";
 import { ControlClient } from "./control-client.js";
 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";
@@ -145,10 +144,9 @@ const dev = Command.make(
 const deploy = Command.make(
   "deploy",
   {
-    resume: Flag.string("resume").pipe(
-      Flag.withDescription("Finish activation of an already uploaded version."),
-      Flag.withSchema(VersionId),
-      Flag.optional,
+    resume: Flag.boolean("resume").pipe(
+      Flag.withDescription("Resume the saved upload or activation."),
+      Flag.withDefault(false),
     ),
     app: Flag.string("app").pipe(
       Flag.withDescription("Create or link this app slug on the first deploy."),
@@ -159,12 +157,8 @@ const deploy = Command.make(
   Effect.fn("deploy")(function* ({ app, resume }) {
     const path = yield* Path.Path;
     const terminal = yield* Terminal.Terminal;
-    if (Option.isSome(resume)) {
-      const result = yield* resumeVersion(
-        path.resolve("."),
-        resume.value,
-        Option.getOrUndefined(app),
-      ).pipe(
+    if (resume) {
+      const result = yield* resumeVersion(path.resolve("."), Option.getOrUndefined(app)).pipe(
         // @effect-diagnostics-next-line strictEffectProvide:off This command owns the authenticated control client.
         Effect.provide(ControlClient.layer),
         Effect.mapError((error) =>
@@ -172,7 +166,7 @@ const deploy = Command.make(
         ),
       );
       yield* terminal.display(
-        `Version ${result.versionNumber} is live.\n\nApp: ${result.appUrl}\nVersion ID: ${result.versionId}\n`,
+        `Version ${result.versionNumber} is live.\n\nApp: ${result.appUrl}\n`,
       );
       return;
     }
@@ -184,9 +178,7 @@ const deploy = Command.make(
       ),
     );
 
-    yield* terminal.display(
-      `Version ${result.versionNumber} is live.\n\nApp: ${result.appUrl}\nVersion ID: ${result.versionId}\n`,
-    );
+    yield* terminal.display(`Version ${result.versionNumber} is live.\n\nApp: ${result.appUrl}\n`);
   }),
 ).pipe(Command.withDescription("Build and deploy the application to Ignotum Cloud."));
 

package/src/cli/control-client.ts

@@ -23,8 +23,8 @@ import {
   controlVersionPath,
 } from "@ignotum/contracts/control";
 import { UploadDeclaration } from "@ignotum/contracts/app-definition";
-import { ExecutionSelection } from "@ignotum/contracts/platform";
-import type { AppId, VersionId } from "@ignotum/contracts/runtime/identity";
+import { ServingSelection } from "@ignotum/contracts/platform";
+import type { AppId, VersionId, VersionNumber } from "@ignotum/contracts/runtime/identity";
 import {
   Config,
   Context,
@@ -111,8 +111,8 @@ export interface VersionUploadFile {
 interface ControlClientService {
   readonly activateVersion: (
     appId: AppId,
-    versionId: VersionId,
-  ) => Effect.Effect<ExecutionSelection, ControlApiError | ControlClientUnavailable>;
+    number: VersionNumber,
+  ) => Effect.Effect<ServingSelection, ControlApiError | ControlClientUnavailable>;
   readonly beginVersion: (
     appId: AppId,
     versionId: VersionId,
@@ -329,13 +329,11 @@ export const controlClientLayer = Layer.effect(
 
     const activateVersion = Effect.fn("ControlClient.activateVersion")(function* (
       appId: AppId,
-      versionId: VersionId,
+      number: VersionNumber,
     ) {
       return yield* executeIdempotent(
-        HttpClientRequest.post(
-          endpoint(config.apiUrl, controlVersionActivatePath(appId, versionId)),
-        ),
-        ExecutionSelection,
+        HttpClientRequest.post(endpoint(config.apiUrl, controlVersionActivatePath(appId, number))),
+        ServingSelection,
       );
     });
 

package/src/cli/deploy.ts

@@ -11,6 +11,8 @@ import {
   type VersionUploadFile,
 } from "./control-client.js";
 
+import { saveUpload, loadUpload, restoreUploadBuild, clearUpload } from "./upload-journal.js";
+
 export class VersionUploadInterrupted extends Schema.TaggedError<VersionUploadInterrupted>()(
   "VersionUploadInterrupted",
   { cause: Schema.Defect(), versionId: VersionId, message: Schema.String },
@@ -35,7 +37,7 @@ const activationError = (
         cause,
         versionId: version.id,
         versionNumber: version.number,
-        message: `Version ${version.number} (${version.id}) is ready, but activation could not be confirmed. Run ignotum deploy --resume ${version.id} to finish activation.`,
+        message: `Version ${version.number} is ready, but activation could not be confirmed. Run ignotum deploy --resume to finish activation.`,
       })
     : cause;
 
@@ -45,7 +47,8 @@ const readyVersion = (version: ControlVersion) =>
     : Effect.fail(
         ControlClientUnavailable.make({
           cause: { versionId: version.id, status: version.status },
-          message: `Version ${version.id} is not ready for activation.`,
+          message:
+            "The saved upload is not ready for activation. Run ignotum deploy to start a new upload.",
         }),
       );
 
@@ -59,10 +62,22 @@ export const buildVersionArtifact = Effect.fn("Deploy.buildArtifact")(function*
 export const uploadVersion = Effect.fn("Deploy.upload")(function* (
   configuration: AppConfiguration,
   build: ManagedVersionBuildResult,
+  savedVersionId?: VersionId,
 ) {
   const control = yield* ControlClient;
-  const versionId = yield* (yield* IdGenerator).generate(VersionId);
-  const admission = yield* control.beginVersion(configuration.appId, versionId, build.declaration);
+  const versionId = savedVersionId ?? (yield* (yield* IdGenerator).generate(VersionId));
+  const admission = yield* control
+    .beginVersion(configuration.appId, versionId, build.declaration)
+    .pipe(
+      Effect.catchTags({
+        ControlClientUnavailable: (cause) =>
+          VersionUploadInterrupted.make({
+            cause,
+            versionId,
+            message: "Upload admission could not be confirmed. Run ignotum deploy --resume.",
+          }),
+      }),
+    );
   const files = yield* Effect.forEach(admission.targets, (target) => {
     const publicArtifact = build.declaration.definition.artifacts.find(
       (artifact) => artifact.path === target.path,
@@ -110,7 +125,7 @@ export const uploadVersion = Effect.fn("Deploy.upload")(function* (
         VersionUploadInterrupted.make({
           cause,
           versionId,
-          message: `Version ${versionId} was interrupted during upload. The active version was not changed.`,
+          message: "Upload interrupted. Run ignotum deploy --resume.",
         }),
     }),
   );
@@ -120,15 +135,15 @@ export const uploadVersion = Effect.fn("Deploy.upload")(function* (
         VersionUploadInterrupted.make({
           cause,
           versionId,
-          message: `Version ${versionId} could not be finalized. The active version was not changed.`,
+          message: "Upload finalization could not be confirmed. Run ignotum deploy --resume.",
         }),
     }),
     Effect.flatMap(readyVersion),
   );
   const selection = yield* control
-    .activateVersion(configuration.appId, versionId)
+    .activateVersion(configuration.appId, version.number)
     .pipe(Effect.mapError((cause) => activationError(version, cause)));
-  if (selection.appId !== configuration.appId || selection.versionId !== versionId) {
+  if (selection.appId !== configuration.appId || selection.versionNumber !== version.number) {
     return yield* activationError(
       version,
       ControlClientUnavailable.make({
@@ -146,24 +161,38 @@ export const deploy = Effect.fn("Deploy.run")(function* (
 ) {
   const build = yield* buildVersionArtifact(appDirectory);
   const configuration = yield* configureApp(appDirectory, requestedSlug);
-  const activated = yield* uploadVersion(configuration, build);
+  const versionId = yield* (yield* IdGenerator).generate(VersionId);
+  yield* saveUpload(appDirectory, configuration, versionId, build);
+  const activated = yield* uploadVersion(configuration, build, versionId);
+  yield* clearUpload(appDirectory);
   return { ...activated, appUrl: appUrl(configuration.slug) };
 });
 
 export const resumeVersion = Effect.fn("Deploy.resume")(function* (
   appDirectory: string,
-  versionId: VersionId,
   requestedSlug?: AppSlug,
 ) {
   const configuration = yield* configureApp(appDirectory, requestedSlug);
   const control = yield* ControlClient;
-  const version = yield* control
-    .getVersion(configuration.appId, versionId)
-    .pipe(Effect.flatMap(readyVersion));
+  const journal = yield* loadUpload(appDirectory, configuration);
+  const versionId = journal.versionId;
+  const existing = yield* control.getVersion(configuration.appId, versionId).pipe(
+    Effect.catchTags({
+      ControlApiError: (error) =>
+        error.status === 404 ? Effect.succeed(undefined) : Effect.fail(error),
+    }),
+  );
+  if (existing === undefined || existing.status === "Uploading") {
+    const build = yield* restoreUploadBuild(appDirectory, journal);
+    const activated = yield* uploadVersion(configuration, build, versionId);
+    yield* clearUpload(appDirectory);
+    return { ...activated, appUrl: appUrl(configuration.slug) };
+  }
+  const version = yield* readyVersion(existing);
   const selection = yield* control
-    .activateVersion(configuration.appId, versionId)
+    .activateVersion(configuration.appId, version.number)
     .pipe(Effect.mapError((cause) => activationError(version, cause)));
-  if (selection.appId !== configuration.appId || selection.versionId !== versionId) {
+  if (selection.appId !== configuration.appId || selection.versionNumber !== version.number) {
     return yield* activationError(
       version,
       ControlClientUnavailable.make({
@@ -172,6 +201,7 @@ export const resumeVersion = Effect.fn("Deploy.resume")(function* (
       }),
     );
   }
+  yield* clearUpload(appDirectory);
   return {
     appUrl: appUrl(configuration.slug),
     versionId,

package/src/cli/dev.ts

@@ -4,7 +4,11 @@ import tailwindcss from "@tailwindcss/vite";
 import { Crypto, Effect, FileSystem, Option, Path, Schema, Scope } from "effect";
 import { createServer, normalizePath, type Plugin, type ViteDevServer } from "vite";
 import { ChildProcessSpawner } from "effect/unstable/process";
-import { ExecutionSelection, RuntimeRequirements } from "@ignotum/contracts/platform";
+import {
+  PlatformRequirement,
+  revisionPrefix,
+  ServingSelection,
+} from "@ignotum/contracts/deployment";
 import { managedSelectionPath } from "@ignotum/contracts/managed-sync";
 import { renderDocument } from "@ignotum/shared/document";
 import { compilePatterns, matchLocation, resolveMetadata } from "@ignotum/shared/routing";
@@ -15,14 +19,14 @@ import { generateClientRoutes, type ClientRouteDiscovery } from "./route-codegen
 import { createImageAssetsPlugin } from "./image-assets.js";
 import { managedClientBoundariesPlugin } from "./managed-client-boundaries.js";
 import { moduleBoundariesPlugin } from "./module-boundaries.js";
-import { managedBrowserExports, managedPreactPeerPlugin } from "./managed-exports.js";
-import { localManagedReleaseProvider } from "./managed-release.js";
+import { platformImportsPlugin } from "@ignotum/platform/compiler";
+import { compilerExports } from "@ignotum/platform/compiler-exports";
 import {
   buildLocalBrowserTools,
-  localExecutionSelection,
-  localPlatformRelease,
-  localPlatformUrl,
-  type LocalManagedRelease,
+  loadLocalPlatform,
+  localServingSelection,
+  localVersionId,
+  type LocalPlatform,
 } from "./managed-dev-platform.js";
 import { acquireDevDatabaseLock, devDatabasePath } from "../dev-runtime/dev-database.js";
 import { ignotumManagedSyncPlugin } from "../dev-runtime/sync.js";
@@ -48,12 +52,10 @@ const toolingPrefix = "/_ignotum/development/tools/";
 
 export interface ManagedDevOptions extends DevOptions {
   readonly applicationName?: string;
-  readonly sdkDirectory?: string;
-  readonly provider?: LocalManagedRelease;
+  readonly provider?: LocalPlatform;
 }
 
 export const renderDevRegistration = (discovery: ClientRouteDiscovery, applicationName: string) => `
-import { mountClient } from "ignotum/internal/bootstrap";
 import ${JSON.stringify(`${toolingPrefix}debug.js`)};
 import ${JSON.stringify(stylesId)};
 const registration = {
@@ -62,18 +64,12 @@ const registration = {
   layouts: ${JSON.stringify(discovery.layouts)},
   modules: new Map([${discovery.modules.map((module) => `[${JSON.stringify(module.id)}, { load: () => import(${JSON.stringify(`/@fs/${normalizePath(module.path)}`)}) }]`).join(",\n")}]),
 };
-let mounted;
-export default function mount(selection) {
-  import.meta.hot.data.selection = selection;
-  mounted?.dispose();
-  mounted = mountClient(registration, selection);
-  return mounted;
-}
 if (import.meta.hot) {
-  import.meta.hot.accept();
-  import.meta.hot.dispose(() => mounted?.dispose());
-  if (import.meta.hot.data.selection) mount(import.meta.hot.data.selection);
+  import.meta.hot.accept((next) => {
+    window.dispatchEvent(new CustomEvent("ignotum:dev-registration", { detail: next.default }));
+  });
 }
+export default registration;
 `;
 
 /** Internal assembly until all CLI producers switch together. The caller owns its Effect scope. */
@@ -85,7 +81,6 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
   const appDirectory = yield* fs.realPath(options.appDirectory);
   const appName = options.applicationName ?? path.basename(appDirectory);
   const clientDirectory = path.join(appDirectory, "client");
-  const sdkDirectory = options.sdkDirectory ?? fileURLToPath(new URL("../../", import.meta.url));
   const validateFiles = Effect.fn("ManagedDev.validateFiles")(function* () {
     for (const publicPath of [
       path.join(appDirectory, "public"),
@@ -114,9 +109,9 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
   let icon = yield* validateFiles();
   let discovery = yield* generateClientRoutes(appDirectory);
   let patterns = yield* compilePatterns(discovery.routes, discovery.layouts);
-  let provider = options.provider ?? (yield* localManagedReleaseProvider(sdkDirectory));
-  let selection = localExecutionSelection(appDirectory, provider);
-  let tools = yield* buildLocalBrowserTools(provider, selection);
+  let provider = options.provider ?? (yield* loadLocalPlatform());
+  let selection = localServingSelection(appDirectory);
+  let tools = yield* buildLocalBrowserTools();
   const runPromise = Effect.runPromiseWith(
     yield* Effect.context<
       | FileSystem.FileSystem
@@ -133,48 +128,14 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
   let work = Promise.resolve();
   const images = yield* createImageAssetsPlugin(appDirectory);
   const boundaries = yield* moduleBoundariesPlugin("Client", appDirectory);
-  const platform = yield* managedClientBoundariesPlugin(appDirectory);
-  const peers = yield* managedPreactPeerPlugin({ resolvePeer: (specifier) => specifier });
-  // These checks run before the resolver turns supported externals into selected graph URLs.
-  const originalPlatformResolve = platform.resolveId;
-  platform.resolveId = function (specifier, importer) {
-    if (importer === `\0${registrationId}` && specifier === "ignotum/internal/bootstrap")
-      return {
-        id: localPlatformUrl(selection.platformReleaseId, provider.resolve("Browser", specifier)!),
-        external: true as const,
-      };
-    const resolved = originalPlatformResolve.call(this, specifier, importer);
-    if (resolved !== undefined && resolved.external) {
-      const module = provider.resolve("Browser", specifier);
-      if (module === undefined) this.error(`The local platform does not supply ${specifier}.`);
-      return { id: localPlatformUrl(selection.platformReleaseId, module), external: true as const };
-    }
-    return resolved;
-  };
-  const originalPeerResolve = peers.resolveId;
-  peers.resolveId = async function (specifier, importer) {
-    const resolved = await originalPeerResolve.call(this, specifier, importer);
-    return resolved === undefined
-      ? undefined
-      : {
-          id: localPlatformUrl(
-            selection.platformReleaseId,
-            provider.resolve("Browser", specifier)!,
-          ),
-          external: true as const,
-        };
-  };
+  const platform = yield* managedClientBoundariesPlugin(appDirectory, true);
   const databasePath = yield* devDatabasePath(appDirectory);
   yield* fs.makeDirectory(path.dirname(databasePath), { recursive: true });
   yield* acquireDevDatabaseLock(appDirectory);
   let loader = yield* createManagedFunctionLoader(appDirectory, {
     guest: provider.guest,
-    release: localPlatformRelease(provider, selection),
-    requirements: Schema.decodeUnknownSync(RuntimeRequirements)({
-      clientApiVersion: 1,
-      serverApiVersion: 1,
-      capabilities: ["operations", "routing", "images"],
-    }),
+    platform: selection.platform,
+    requirements: Schema.decodeUnknownSync(PlatformRequirement)({ major: 1, minimumMinor: 0 }),
   });
   const compileServer = Effect.fn("ManagedDev.compileServer")(function* () {
     const generated = yield* generate(appDirectory);
@@ -188,6 +149,7 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
   yield* compileServer();
   const sync = ignotumManagedSyncPlugin(appDirectory, databasePath, {
     selection: () => selection,
+    versionId: localVersionId(appDirectory),
     isServerDependency: (file) => {
       const relative = normalizePath(path.relative(appDirectory, file));
       return (
@@ -232,7 +194,7 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
           id: `${toolingPrefix}${id.slice("@prefresh/".length)}.js`,
           external: true as const,
         };
-      if (id.startsWith(toolingPrefix) || id.startsWith("/_ignotum/platform/"))
+      if (id.startsWith(toolingPrefix) || id.startsWith("/_ignotum/v"))
         return { id, external: true as const };
     },
     load(id) {
@@ -247,11 +209,7 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
       // Prefresh adds optimizer entries. Its tools are already compiled against the managed renderer.
       config.optimizeDeps.include = [];
       config.optimizeDeps.noDiscovery = true;
-      config.optimizeDeps.exclude = [
-        ...managedBrowserExports.map((entry) => entry.specifier),
-        "@prefresh/core",
-        "@prefresh/utils",
-      ];
+      config.optimizeDeps.exclude = ["ignotum/platform", "@prefresh/core", "@prefresh/utils"];
     },
     configureServer(server) {
       viteServer = server;
@@ -335,17 +293,9 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
           send(JSON.stringify({ protocolVersion: 1, selection }), "application/json");
           return;
         }
-        const platformPrefix = `/_ignotum/platform/${selection.platformReleaseId}/`;
-        if (url.pathname.startsWith(platformPrefix)) {
-          const modulePath = url.pathname.slice(platformPrefix.length);
-          const allowed = provider.browser.manifest.modules.some(
-            (module) => module.path === modulePath,
-          );
-          const bytes = allowed ? provider.read("Browser", modulePath) : undefined;
-          if (bytes === undefined) {
-            response.statusCode = 404;
-            response.end();
-          } else send(bytes, "text/javascript", true);
+        const browserEntry = `${revisionPrefix(selection.platform)}/client.js`;
+        if (url.pathname === browserEntry) {
+          send(provider.browser, "text/javascript", true);
           return;
         }
         if (url.pathname.startsWith(toolingPrefix)) {
@@ -392,20 +342,21 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
                 outcome: outcome._tag,
               }),
             );
-            const imports = Object.fromEntries(
-              Object.entries(provider.browser.manifest.entries).map(([specifier, module]) => [
-                specifier,
-                localPlatformUrl(selection.platformReleaseId, module),
-              ]),
-            );
+            const browserEntry = `${revisionPrefix(selection.platform)}/client.js`;
             const html = renderDocument({
               metadata,
               selection,
-              importMap: { imports },
-              browserEntry: imports["ignotum/internal/bootstrap"]!,
+              importMap: {
+                imports: {
+                  "ignotum/platform": browserEntry,
+                  "/@id/ignotum/platform": browserEntry,
+                },
+              },
+              browserEntry,
               registration: { module: moduleUrl(registrationId), exportName: "default" },
               styles: [],
               icon: icon?.url,
+              development: true,
             });
             response.statusCode =
               outcome._tag === "NotFound" ? 404 : outcome._tag === "Invalid" ? 400 : 200;
@@ -433,7 +384,7 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
             images.plugin,
             boundaries,
             platform,
-            peers,
+            platformImportsPlugin(compilerExports),
             sync,
             await prefresh(),
             tailwindcss(),
@@ -476,21 +427,21 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
     server,
     selection: () => selection,
     settled: () => work,
-    replacePlatform: (next: LocalManagedRelease) => {
+    replacePlatform: (next: LocalPlatform) => {
       const replace = async () => {
-        const nextSelection = Schema.decodeUnknownSync(ExecutionSelection)({
-          ...localExecutionSelection(appDirectory, next),
-          platformGeneration: selection.platformGeneration + 1,
-        });
-        const nextTools = await runPromise(buildLocalBrowserTools(next, nextSelection));
+        const nextSelection = localServingSelection(
+          appDirectory,
+          selection.deploymentEpoch + 1,
+          selection.activationGeneration + 1,
+        );
+        const nextTools = await runPromise(buildLocalBrowserTools());
         const nextLoader = await runPromise(
           createManagedFunctionLoader(appDirectory, {
             guest: next.guest,
-            release: localPlatformRelease(next, nextSelection),
-            requirements: Schema.decodeUnknownSync(RuntimeRequirements)({
-              clientApiVersion: 1,
-              serverApiVersion: 1,
-              capabilities: ["operations", "routing", "images"],
+            platform: nextSelection.platform,
+            requirements: Schema.decodeUnknownSync(PlatformRequirement)({
+              major: 1,
+              minimumMinor: 0,
             }),
           }),
         );
@@ -506,7 +457,7 @@ export const acquireManagedDevServer = Effect.fn("ManagedDev.acquireServer")(fun
         loader = nextLoader;
         provider = next;
         tools = nextTools;
-        selection = Schema.decodeUnknownSync(ExecutionSelection)(nextSelection);
+        selection = Schema.decodeUnknownSync(ServingSelection)(nextSelection);
         serverDiagnostic = undefined;
         server.environments.client.moduleGraph.invalidateAll();
         // Managed sync checks the new selection even for sockets with no active queries.

package/src/cli/image-assets.ts

@@ -8,7 +8,6 @@ import { normalizePath } from "vite";
 import type { Plugin, ResolvedConfig, ViteDevServer } from "vite";
 
 const imageModulePrefix = "\0ignotum:image:";
-const assetUrlPrefix = "/_ignotum/";
 const imageModuleId = (sourcePath: string): string =>
   `${imageModulePrefix}${encodeURIComponent(normalizePath(sourcePath))}.js`;
 
@@ -147,7 +146,9 @@ const cssImageNodes = (parsed: ReturnType<typeof valueParser>): ReadonlyArray<va
 
 export const createImageAssetsPlugin = Effect.fn("Deploy.createImageAssetsPlugin")(function* (
   appDirectory: string,
+  deployment = false,
 ) {
+  const assetUrlPrefix = deployment ? "/_ignotum/assets/" : "/_ignotum/";
   const fileSystem = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
   const runPromise = Effect.runPromiseWith(yield* Effect.context<Crypto.Crypto>());
@@ -267,7 +268,9 @@ export const createImageAssetsPlugin = Effect.fn("Deploy.createImageAssetsPlugin
 
     const digest = yield* sha256(bytes);
     const format = imageFormats[extension];
-    const artifactPath = `assets/${digest}/image.${format.canonicalExtension}`;
+    const artifactPath = deployment
+      ? `media/${path.basename(absolutePath, path.extname(absolutePath)).replace(/[^a-zA-Z0-9.-]/g, "_")}-${digest}.${format.canonicalExtension}`
+      : `assets/${digest}/image.${format.canonicalExtension}`;
     let asset = assets.get(artifactPath);
     if (asset === undefined) {
       asset = {

package/src/cli/managed-client-boundaries.ts

@@ -1,18 +1,16 @@
 import { Effect, FileSystem, Path, Schema } from "effect";
 import { normalizePath, type Plugin } from "vite";
-import { managedBrowserExports } from "./managed-exports.js";
+import { compilerExports } from "@ignotum/platform/compiler-exports";
 import { InvalidBuildOutput } from "./build/artifact.js";
 
 const PackageMetadata = Schema.Struct({ name: Schema.optional(Schema.String) });
 const externals = new Set<string>(
-  managedBrowserExports
-    .filter((entry) => entry.specifier.startsWith("ignotum/"))
-    .map((entry) => entry.specifier),
+  Object.keys(compilerExports).filter((specifier) => specifier.startsWith("ignotum/")),
 );
 
 /** Resolve before workspace conditions or package aliases can embed SDK implementation. */
 export const managedClientBoundariesPlugin = Effect.fn("Deploy.managedClientBoundariesPlugin")(
-  function* (appDirectory: string) {
+  function* (appDirectory: string, sharedImports = false) {
     const fs = yield* FileSystem.FileSystem;
     const path = yield* Path.Path;
     const runPromise = Effect.runPromiseWith(yield* Effect.context<never>());
@@ -70,7 +68,9 @@ export const managedClientBoundariesPlugin = Effect.fn("Deploy.managedClientBoun
             message: `Managed client module '${importer ?? "<entry>"}' imports unsupported platform entry '${specifier}'. Compiler-owned entries must come from generated bindings.`,
           });
         }
-        if (externals.has(specifier)) return { id: specifier, external: true };
+        if (externals.has(specifier))
+          return sharedImports ? undefined : { id: specifier, external: true };
+        if (sharedImports && specifier === "ignotum/platform") return;
         if (
           specifier === "ignotum" ||
           specifier.startsWith("ignotum/") ||