ignotum 0.0.16 → 0.0.18

package/src/cli/managed-dev-platform.ts

@@ -1,70 +1,63 @@
 import { createHash } from "node:crypto";
-import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
-import { Effect, Path, Schema } from "effect";
-import { ExecutionSelection, PlatformRelease } from "@ignotum/contracts/platform";
-import { managedPreactPeers } from "./managed-exports.js";
-import { localManagedReleaseProvider } from "./managed-release.js";
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { ServingSelection, type PlatformRevision } from "@ignotum/contracts/deployment";
+import { VersionId } from "@ignotum/contracts/runtime/identity";
+import { bundledGuests } from "@ignotum/platform/guests";
+import type { BundledGuest } from "@ignotum/platform/artifacts";
+import { compilerExports } from "@ignotum/platform/compiler-exports";
+import { platformImportsPlugin } from "@ignotum/platform/compiler";
 import { runViteBuild } from "./build/artifact.js";
 
-export type LocalManagedRelease = Effect.Success<ReturnType<typeof localManagedReleaseProvider>>;
+export interface LocalPlatform {
+  readonly revision: PlatformRevision;
+  readonly browser: Uint8Array;
+  readonly guest: BundledGuest;
+}
 
-export const localPlatformUrl = (release: string, module: string) =>
-  `/_ignotum/platform/${release}/${module}`;
+export const loadLocalPlatform = Effect.fn("ManagedDev.loadPlatform")(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const revision = { major: 1, minor: 0 } as const;
+  const guest = bundledGuests.find(
+    (candidate) =>
+      candidate.manifest.revision.major === revision.major &&
+      candidate.manifest.revision.minor === revision.minor,
+  );
+  if (guest === undefined) return yield* Effect.die("The local platform guest is missing.");
+  const browser = yield* fs.readFile(
+    fileURLToPath(new URL("../../dist/platform/_ignotum/v1.0/client.js", import.meta.url)),
+  );
+  return { revision, browser, guest } satisfies LocalPlatform;
+});
 
-export const localExecutionSelection = (appDirectory: string, provider: LocalManagedRelease) => {
-  const digest = (value: string) => createHash("sha256").update(value).digest("hex").slice(0, 24);
-  return Schema.decodeUnknownSync(ExecutionSelection)({
-    formatVersion: 1,
-    appId: `app_${digest(appDirectory)}`,
-    versionId: `dep_${digest(appDirectory)}`,
-    activationGeneration: 1,
-    platformReleaseId: `rel_${digest(provider.browser.sha256 + provider.guest.sha256)}`,
-    platformGeneration: 1,
-    dataHistoryId: `hist_${digest(appDirectory)}`,
-  });
+export const localVersionId = (appDirectory: string) => {
+  const digest = createHash("sha256").update(appDirectory).digest("hex").slice(0, 24);
+  return VersionId.make(`dep_${digest}`);
 };
 
-export const localPlatformRelease = (
-  provider: LocalManagedRelease,
-  selection: ExecutionSelection,
-) =>
-  Schema.decodeUnknownSync(PlatformRelease)({
+export const localServingSelection = (
+  appDirectory: string,
+  deploymentEpoch = 1,
+  activationGeneration = 1,
+) => {
+  const digest = createHash("sha256").update(appDirectory).digest("hex").slice(0, 24);
+  return Schema.decodeUnknownSync(ServingSelection)({
     formatVersion: 1,
-    id: selection.platformReleaseId,
-    browser: {
-      graph: {
-        sha256: provider.browser.sha256,
-        entry: provider.browser.manifest.entries["ignotum/internal/bootstrap"],
-      },
-      clientApiVersion: 1,
-      protocolVersion: 1,
-    },
-    guest: {
-      graph: {
-        sha256: provider.guest.sha256,
-        entry: provider.guest.manifest.entries["ignotum/internal/host"],
-      },
-      serverApiVersion: 1,
-      protocolVersion: 1,
-    },
-    gateway: { implementation: provider.browser.sha256, browserProtocols: [1] },
-    host: { implementation: provider.guest.sha256, guestProtocols: [1] },
-    capabilities: ["operations", "routing", "images"],
-    persistentState: [],
-    publication: { state: "Ready", eligible: true },
+    appId: `app_${digest}`,
+    versionNumber: 1,
+    platform: { major: 1, minor: 0 },
+    activationGeneration,
+    deploymentEpoch,
+    dataHistoryId: `hist_${digest}`,
   });
+};
 
-/** Development tools share the selected renderer; they never enter application modules. */
-export const buildLocalBrowserTools = Effect.fn("ManagedDev.buildBrowserTools")(function* (
-  provider: LocalManagedRelease,
-  selection: ExecutionSelection,
-) {
+/** Development tools use the same single platform module as application code. */
+export const buildLocalBrowserTools = Effect.fn("ManagedDev.buildBrowserTools")(function* () {
   const path = yield* Path.Path;
-  const require = createRequire(import.meta.resolve("@prefresh/vite"));
   const entries = {
-    core: require.resolve("@prefresh/core"),
-    utils: require.resolve("@prefresh/utils"),
+    core: fileURLToPath(import.meta.resolve("@prefresh/core")),
+    utils: fileURLToPath(import.meta.resolve("@prefresh/utils")),
     debug: fileURLToPath(import.meta.resolve("preact/debug")),
   };
   const sources = new Map([
@@ -80,23 +73,15 @@ export const buildLocalBrowserTools = Effect.fn("ManagedDev.buildBrowserTools")(
     logLevel: "warn",
     define: { "process.env.NODE_ENV": JSON.stringify("development") },
     plugins: [
+      platformImportsPlugin(compilerExports),
       {
-        name: "ignotum:local-tooling-renderer",
+        name: "ignotum:local-browser-tools",
         generateBundle(_options, bundle) {
           for (const item of Object.values(bundle))
             if (item.type === "chunk") files.set(item.fileName, item.code);
         },
-        load(id) {
-          return sources.get(id);
-        },
-        resolveId(id) {
-          if (sources.has(`\0${id}`)) return `\0${id}`;
-          if (managedPreactPeers.some((peer) => peer.specifier === id)) {
-            const module = provider.resolve("Browser", id);
-            if (module === undefined) this.error(`Missing managed rendering peer ${id}.`);
-            return { id: localPlatformUrl(selection.platformReleaseId, module), external: true };
-          }
-        },
+        load: (id) => sources.get(id),
+        resolveId: (id) => (sources.has(`\0${id}`) ? `\0${id}` : undefined),
       },
     ],
     build: {
@@ -105,6 +90,7 @@ export const buildLocalBrowserTools = Effect.fn("ManagedDev.buildBrowserTools")(
       target: "es2020",
       rolldownOptions: {
         input: { core: "ignotum:dev-core", utils: "ignotum:dev-utils", debug: "ignotum:dev-debug" },
+        external: ["ignotum/platform"],
         preserveEntrySignatures: "strict",
         output: {
           format: "es",

package/src/cli/managed-exports.ts

@@ -2,74 +2,13 @@ import { Effect, FileSystem, Path, Schema } from "effect";
 import { satisfies, validRange } from "semver";
 import type { Plugin } from "vite";
 
-export interface ManagedExport {
-  readonly specifier: string;
-  /** Relative to the SDK src directory, or a Preact package specifier. */
-  readonly source: string;
-  readonly fileName: string;
-}
-
 export const managedPreactVersion = "10.29.8";
 export const managedPreactPeers = [
-  { specifier: "preact", source: "preact", fileName: "preact" },
-  { specifier: "preact/hooks", source: "preact/hooks", fileName: "preact-hooks" },
-  { specifier: "preact/jsx-runtime", source: "preact/jsx-runtime", fileName: "preact-jsx-runtime" },
-  {
-    specifier: "preact/jsx-dev-runtime",
-    source: "preact/jsx-dev-runtime",
-    fileName: "preact-jsx-dev-runtime",
-  },
-] as const satisfies ReadonlyArray<ManagedExport>;
-
-export const managedBrowserExports = [
-  { specifier: "ignotum/client", source: "client/index.ts", fileName: "client" },
-  {
-    specifier: "ignotum/client/jsx-runtime",
-    source: "client/jsx-runtime.ts",
-    fileName: "jsx-runtime",
-  },
-  {
-    specifier: "ignotum/client/jsx-dev-runtime",
-    source: "client/jsx-dev-runtime.ts",
-    fileName: "jsx-dev-runtime",
-  },
-  { specifier: "ignotum/internal/api", source: "internal/api.ts", fileName: "api" },
-  { specifier: "ignotum/internal/client", source: "internal/client.ts", fileName: "bindings" },
-  { specifier: "ignotum/internal/routes", source: "internal/routes.ts", fileName: "routes" },
-  { specifier: "ignotum/internal/bootstrap", source: "client/bootstrap.ts", fileName: "bootstrap" },
-  ...managedPreactPeers,
-] as const satisfies ReadonlyArray<ManagedExport>;
-
-export const managedGuestExports = [
-  { specifier: "ignotum/server", source: "server/index.ts", fileName: "server" },
-  { specifier: "ignotum/internal/server", source: "internal/server.ts", fileName: "bindings" },
-  { specifier: "ignotum/internal/api", source: "internal/api.ts", fileName: "api" },
-  { specifier: "ignotum/internal/host", source: "internal/host.ts", fileName: "host" },
-] as const satisfies ReadonlyArray<ManagedExport>;
-
-export const managedCompatibility = {
-  clientApiVersion: 1,
-  serverApiVersion: 1,
-  protocolVersions: [1],
-  capabilities: ["operations", "routing", "images"],
-} as const;
-
-export const resolveLocalManagedExport = Effect.fn("Deploy.resolveLocalManagedExport")(
-  function* (options: {
-    readonly target: "browser" | "guest";
-    readonly sdkSourceRoot: string;
-    readonly specifier: string;
-  }) {
-    const path = yield* Path.Path;
-    const entries = options.target === "browser" ? managedBrowserExports : managedGuestExports;
-    const entry = entries.find((entry) => entry.specifier === options.specifier);
-    return entry === undefined
-      ? undefined
-      : entry.source.startsWith("preact")
-        ? entry.source
-        : path.resolve(options.sdkSourceRoot, entry.source);
-  },
-);
+  { specifier: "preact", fileName: "preact" },
+  { specifier: "preact/hooks", fileName: "preact-hooks" },
+  { specifier: "preact/jsx-runtime", fileName: "preact-jsx-runtime" },
+  { specifier: "preact/jsx-dev-runtime", fileName: "preact-jsx-dev-runtime" },
+] as const;
 
 export class ManagedPeerError extends Schema.TaggedError<ManagedPeerError>()("ManagedPeerError", {
   packageName: Schema.String,

package/src/cli/new-app.ts

@@ -1,5 +1,6 @@
 import { Effect, FileSystem, Path, Schema, String } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import cliPackageJson from "../../package.json" with { type: "json" };
 
 import { agentAppFiles, type AppFile } from "./agent-files.js";
 import { generateClientRoutes } from "./route-codegen.js";
@@ -52,7 +53,7 @@ const packageJson = (appName: string): string =>
         typecheck: "ignotum codegen && tsc --noEmit",
       },
       dependencies: {
-        ignotum: "latest",
+        ignotum: cliPackageJson.version,
       },
       devDependencies: {
         typescript: "^7.0.2",
@@ -256,7 +257,7 @@ After generating bindings, run \`npx tsc --noEmit\` to check the app.
 Sign in with \`npx ignotum auth login\`, then run \`npx ignotum deploy --app my-app\`.
 Later deployments use \`npx ignotum deploy\`. The command prints the hosted URL and confirms
 that the numbered App Version is live. If activation cannot be confirmed, follow the printed
-\`ignotum deploy --resume <version-id>\` command to finish without creating another version.
+\`ignotum deploy --resume\` command to finish without creating another version.
 
 ## Coding agents
 
@@ -277,6 +278,10 @@ export const appFiles = (appName: string): ReadonlyArray<AppFile> => [
   { content: schema, path: "server/schema.ts" },
   { content: utils, path: "shared/utils.ts" },
   { content: packageJson(appName), path: "package.json" },
+  {
+    content: `minimumReleaseAgeExclude:\n  - ignotum@${cliPackageJson.version}\nallowBuilds:\n  msgpackr-extract: false\n`,
+    path: "pnpm-workspace.yaml",
+  },
   { content: tsconfig, path: "tsconfig.json" },
   { content: gitignore, path: ".gitignore" },
   { content: readme(appName), path: "README.md" },

package/src/cli/path.ts

@@ -0,0 +1,11 @@
+import type { Path } from "effect";
+
+export const PathContainment = {
+  contains(path: Path.Path, directory: string, child: string): boolean {
+    const relative = path.relative(directory, child);
+    return (
+      relative === "" ||
+      (!path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`))
+    );
+  },
+};

package/src/cli/route-codegen.ts

@@ -15,6 +15,7 @@ import {
   writeOutput,
 } from "./codegen.js";
 import { createRouteExtractor, InvalidRouteSource, sourceError } from "./route-static.js";
+import { PathContainment } from "./path.js";
 
 export interface DiscoveredClientModule {
   readonly path: string;
@@ -54,7 +55,7 @@ export const discoverClientRoutes = Effect.fn("Routes.discoverClientRoutes")(fun
     const real = yield* fs
       .realPath(directory)
       .pipe(Effect.mapError(() => diagnostic(directory, "Cannot read route directory.")));
-    if (real !== clientDirectory && !real.startsWith(`${clientDirectory}/`))
+    if (!PathContainment.contains(path, clientDirectory, real))
       return yield* diagnostic(directory, "Route trees cannot escape client/ through symlinks.");
     if (seen.has(real)) return yield* diagnostic(directory, "Repeated or cyclic route directory.");
     seen.add(real);

package/src/cli/route-static.ts

@@ -5,6 +5,7 @@ import {
   StaticMetadata,
   UrlValueDescriptor,
 } from "@ignotum/contracts/app-definition";
+import { PathContainment } from "./path.js";
 
 export class InvalidRouteSource extends Schema.TaggedError<InvalidRouteSource>()(
   "InvalidRouteSource",
@@ -126,8 +127,8 @@ export const createRouteExtractor = Effect.fn("Routes.createExtractor")(function
       .realPath(file)
       .pipe(Effect.mapError(() => fail("Cannot read source module.")));
     if (
-      !real.startsWith(`${appDirectory}/`) ||
-      real.startsWith(`${appDirectory}/server/`) ||
+      !PathContainment.contains(path, appDirectory, real) ||
+      PathContainment.contains(path, path.join(appDirectory, "server"), real) ||
       !/\.(ts|tsx)$/.test(real) ||
       real.endsWith(".d.ts")
     )

package/src/cli/upload-journal.ts

@@ -0,0 +1,130 @@
+import { Effect, FileSystem, Path, Schema } from "effect";
+import { UploadDeclaration } from "@ignotum/contracts/app-definition";
+import { EnvironmentArtifact, Sha256 } from "@ignotum/contracts/version";
+import { AppId, VersionId } from "@ignotum/contracts/runtime/identity";
+import * as Versioned from "@ignotum/contracts/versioned";
+import { encodeCanonical, sha256, utf8Bytes } from "@ignotum/versions";
+import { AppConfigurationInvalid, type AppConfiguration } from "./app-configuration.js";
+import type { ManagedVersionBuildResult } from "./build/managed.js";
+import { readEnvironmentRaw } from "./environment.js";
+
+const UploadJournalV1 = Schema.Struct({
+  formatVersion: Schema.Literal(1),
+  appId: AppId,
+  versionId: VersionId,
+  apiUrl: Schema.String,
+  declarationSha256: Sha256,
+  environmentNonce: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/)),
+  hasEnvironmentDefinition: Schema.Boolean,
+});
+const UploadJournal = Versioned.initial(UploadJournalV1);
+export type UploadJournal = typeof UploadJournal.Type;
+const invalid = () =>
+  AppConfigurationInvalid.make({
+    message:
+      "The saved upload does not match this app, build, or environment. Run ignotum deploy to start a new upload.",
+  });
+
+export const saveUpload = Effect.fn("UploadJournal.save")(function* (
+  appDirectory: string,
+  configuration: AppConfiguration,
+  versionId: VersionId,
+  build: ManagedVersionBuildResult,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const environment = yield* Schema.decodeEffect(Schema.fromJsonString(EnvironmentArtifact))(
+    new TextDecoder().decode(build.environment.bytes),
+  ).pipe(Effect.mapError(invalid));
+  const journal: UploadJournal = {
+    formatVersion: 1,
+    appId: configuration.appId,
+    versionId,
+    apiUrl: configuration.apiUrl.href,
+    declarationSha256: yield* sha256(build.declarationBytes),
+    environmentNonce: environment.nonce,
+    hasEnvironmentDefinition: yield* fs.exists(path.join(appDirectory, "server/env.ts")),
+  };
+  const directory = path.join(appDirectory, ".ignotum");
+  yield* fs.makeDirectory(directory, { recursive: true });
+  yield* Effect.scoped(
+    Effect.gen(function* () {
+      const temporary = yield* fs.makeTempFileScoped({ directory, prefix: ".upload-" });
+      yield* fs.writeFileString(temporary, encodeCanonical(UploadJournal, journal) + "\n");
+      yield* fs.rename(temporary, path.join(directory, "upload.json"));
+    }),
+  );
+  return journal;
+});
+
+export const loadUpload = Effect.fn("UploadJournal.load")(function* (
+  appDirectory: string,
+  configuration: AppConfiguration,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const text = yield* fs.readFileString(path.join(appDirectory, ".ignotum/upload.json")).pipe(
+    Effect.mapError(() =>
+      AppConfigurationInvalid.make({
+        message: "No saved upload is available. Run ignotum deploy first.",
+      }),
+    ),
+  );
+  const journal = yield* Schema.decodeEffect(Schema.fromJsonString(UploadJournal))(text).pipe(
+    Effect.mapError(invalid),
+  );
+  if (journal.appId !== configuration.appId || journal.apiUrl !== configuration.apiUrl.href)
+    return yield* invalid();
+  return journal;
+});
+
+export const restoreUploadBuild = Effect.fn("UploadJournal.restoreBuild")(function* (
+  appDirectory: string,
+  journal: UploadJournal,
+) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const outputDirectory = path.join(appDirectory, ".ignotum/build");
+  const declarationBytes = yield* fs.readFile(path.join(outputDirectory, "declaration.json"));
+  if ((yield* sha256(declarationBytes)) !== journal.declarationSha256) return yield* invalid();
+  const declaration = yield* Schema.decodeEffect(Schema.fromJsonString(UploadDeclaration))(
+    new TextDecoder().decode(declarationBytes),
+  ).pipe(Effect.mapError(invalid));
+  const entries = yield* Effect.forEach(
+    declaration.definition.artifacts,
+    Effect.fn(function* (artifact) {
+      const bytes = yield* fs.readFile(path.join(outputDirectory, artifact.path));
+      if (bytes.byteLength !== artifact.size || (yield* sha256(bytes)) !== artifact.sha256)
+        return yield* invalid();
+      return [artifact.path, bytes] as const;
+    }),
+  );
+  const raw = yield* readEnvironmentRaw(appDirectory, journal.hasEnvironmentDefinition);
+  const environmentBytes = utf8Bytes(
+    encodeCanonical(EnvironmentArtifact, {
+      formatVersion: 1,
+      nonce: journal.environmentNonce,
+      values: raw.raw,
+    }) + "\n",
+  );
+  const artifact = declaration.environment?.artifact;
+  if (
+    artifact === undefined ||
+    artifact.size !== environmentBytes.byteLength ||
+    artifact.sha256 !== (yield* sha256(environmentBytes))
+  )
+    return yield* invalid();
+  return {
+    declaration,
+    declarationBytes,
+    outputDirectory,
+    bytes: new Map(entries),
+    environment: { path: artifact.path, bytes: environmentBytes },
+  } satisfies ManagedVersionBuildResult;
+});
+
+export const clearUpload = Effect.fn("UploadJournal.clear")(function* (appDirectory: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  yield* fs.remove(path.join(appDirectory, ".ignotum/upload.json"), { force: true });
+});

package/src/client/bootstrap.ts

@@ -1,110 +1 @@
-import type { ExecutionSelection } from "@ignotum/contracts/platform";
-import { createElement, Fragment, render, type ComponentChildren } from "preact";
-import { useLayoutEffect, useState } from "preact/hooks";
-import { mountManagedSync } from "./sync.js";
-import type { ManagedBrowserClient } from "./managed-client.js";
-import { RouterContext, useRouterSnapshot } from "./router.js";
-// oxlint-disable-next-line anti-slop-effect/no-service-constructor-imports -- Each browser mount owns its router and releases it on disposal.
-import { RouterStore, type ClientRegistration } from "./router-store.js";
-
-import { Branch, LoadFailure } from "./route-boundaries.js";
-
-const RouterView = ({ router }: { readonly router: RouterStore }): ComponentChildren => {
-  const snapshot = useRouterSnapshot(router);
-  useLayoutEffect(() => {
-    router.rendered(snapshot.commit);
-  }, [router, snapshot]);
-  return createElement(
-    RouterContext.Provider,
-    { value: router },
-    snapshot.branch === undefined || snapshot.location === undefined
-      ? createElement("div", { role: "status" }, snapshot.failure === undefined ? "Loading…" : null)
-      : createElement(Branch, {
-          branch: snapshot.branch,
-          location: snapshot.location,
-          router,
-          failure: snapshot.failure,
-        }),
-    snapshot.failure !== undefined && snapshot.branch === undefined
-      ? createElement(LoadFailure, { failure: snapshot.failure, router })
-      : null,
-  );
-};
-
-const mounts = new WeakSet<Element>();
-
-const ManagedStatus = ({ client }: { readonly client: ManagedBrowserClient }) => {
-  const [snapshot, setSnapshot] = useState(client.upgrade.getSnapshot);
-  useLayoutEffect(
-    () => client.upgrade.subscribe(() => setSnapshot(client.upgrade.getSnapshot())),
-    [client],
-  );
-  if (snapshot.phase === "ready" && snapshot.recovery.length === 0) return null;
-  return createElement(
-    "aside",
-    {
-      "data-ignotum-update": snapshot.phase,
-      role: snapshot.phase === "error" ? "alert" : "status",
-    },
-    snapshot.message ?? (snapshot.phase === "connecting" ? "Connecting to the app…" : null),
-    snapshot.recovery.length === 0
-      ? null
-      : createElement(
-          "ul",
-          null,
-          snapshot.recovery.map((message) => createElement("li", { key: message }, message)),
-        ),
-    snapshot.phase === "error"
-      ? createElement("button", { type: "button", onClick: () => client.retry() }, "Reload app")
-      : null,
-    snapshot.recovery.length === 0
-      ? null
-      : createElement(
-          "button",
-          { type: "button", onClick: client.upgrade.dismissRecovery },
-          "Dismiss",
-        ),
-  );
-};
-
-/** The platform owns mounting. Generated registrations contain no Preact render/bootstrap code. */
-export const mountClient = (registration: ClientRegistration, selection: ExecutionSelection) => {
-  const root = window.document.getElementById("app");
-  if (root === null) throw new Error("Ignotum mount element is missing.");
-  if (mounts.has(root)) throw new Error("The Ignotum client is already mounted.");
-  const router = new RouterStore(registration, selection, window);
-  const managed = mountManagedSync(selection, window, {
-    stopAdmission: router.stopForUpgrade,
-    reload: router.upgrade,
-  });
-  router.setAdmission({
-    validate: managed.client.validate,
-    recoverLoad: managed.client.recoverLoad,
-  });
-  render(
-    createElement(
-      Fragment,
-      null,
-      createElement(ManagedStatus, { client: managed.client }),
-      createElement(RouterView, { router }),
-    ),
-    root,
-  );
-  const ready = managed.client
-    .whenReady()
-    .then((accepted) => (accepted ? router.start() : { status: "cancelled" as const }));
-  mounts.add(root);
-  let disposed = false;
-  return {
-    ready,
-    upgrade: () => managed.client.upgrade.require(),
-    dispose: () => {
-      if (disposed) return;
-      disposed = true;
-      mounts.delete(root);
-      router.dispose();
-      managed.dispose();
-      render(null, root);
-    },
-  };
-};
+export * from "@ignotum/platform/versions/1/browser/bootstrap";

package/src/client/errors.ts

@@ -1,70 +1 @@
-/** @effect-diagnostics globalConsole:skip-file */
-import { Cause, Effect, ErrorReporter, Schema } from "effect";
-
-import { FunctionAddress } from "@ignotum/contracts/runtime/sync";
-
-export class ConnectionUnavailable extends Schema.TaggedError<ConnectionUnavailable>()(
-  "ConnectionUnavailable",
-  {
-    cause: Schema.optional(Schema.Defect()),
-    message: Schema.String,
-  },
-) {}
-
-export class PlatformUpgrading extends Schema.TaggedError<PlatformUpgrading>()(
-  "PlatformUpgrading",
-  {
-    message: Schema.String,
-  },
-) {}
-
-export class InvalidMutationArguments extends Schema.TaggedError<InvalidMutationArguments>()(
-  "InvalidMutationArguments",
-  {
-    cause: Schema.Defect(),
-    function: FunctionAddress,
-    message: Schema.String,
-  },
-) {}
-
-export class InvalidServerMessage extends Schema.TaggedError<InvalidServerMessage>()(
-  "InvalidServerMessage",
-  {
-    cause: Schema.Defect(),
-    message: Schema.String,
-  },
-) {}
-
-export class ServerError extends Schema.TaggedError<ServerError>()("ServerError", {
-  code: Schema.Literals([
-    "PlatformUpgrading",
-    "SessionExpired",
-    "InvalidMessage",
-    "Unavailable",
-    "InvalidArguments",
-    "InvocationIdConflict",
-    "ResourceLimitExceeded",
-  ]),
-  message: Schema.String,
-}) {}
-
-export const ClientInfrastructureError = Schema.Union([
-  PlatformUpgrading,
-  ConnectionUnavailable,
-  InvalidMutationArguments,
-  InvalidServerMessage,
-  ServerError,
-]);
-export type ClientInfrastructureError = typeof ClientInfrastructureError.Type;
-
-const browserErrorReporter = ErrorReporter.make(({ attributes, error }) => {
-  globalThis.console.error("Ignotum infrastructure error", error, attributes);
-});
-
-export const clientErrorReporterLayer = ErrorReporter.layer([browserErrorReporter]);
-
-export const reportClientError = Effect.fn("ClientErrorReporter.report")(function* (
-  error: ClientInfrastructureError,
-) {
-  yield* ErrorReporter.report(Cause.fail(error));
-});
+export * from "@ignotum/platform/versions/1/browser/errors";