ignotum 0.0.16 → 0.0.17

package/src/dev-runtime/managed-functions.ts

@@ -3,17 +3,16 @@ import { Crypto, Effect, Encoding, FileSystem, Path, Predicate, Schema } from "e
 import type { ViteDevServer } from "vite";
 import { parseSync } from "oxc-parser";
 import { prepareManagedExecution, type ManagedExecution } from "@ignotum/runtime/quickjs";
+import type { BundledGuest } from "@ignotum/runtime/managed-graph";
 import { apiFunctionParts } from "@ignotum/contracts/runtime/sync";
 import { getFunctionEnvironment } from "@ignotum/contracts/runtime/schema";
 import * as serverNamespace from "../server/index.js";
 import * as internalServerNamespace from "../internal/server.js";
 import * as apiNamespace from "../internal/api.js";
-import { validateManagedReleaseGraph } from "@ignotum/versions/managed-release";
 import { descriptorCodec } from "@ignotum/runtime/schema";
 import { SchemaSnapshotField } from "@ignotum/contracts/version";
 import { attachValueDescriptor, defineEnv, emptyEnv } from "@ignotum/contracts/schema";
 import type { ManagedServerBuildResult } from "../cli/build/managed-server.js";
-import type { buildManagedReleaseGraph } from "../cli/managed-release.js";
 
 type DevelopmentModule = Awaited<ReturnType<ViteDevServer["ssrLoadModule"]>>;
 const literal = Schema.encodeSync(Schema.fromJsonString(Schema.String));
@@ -39,8 +38,8 @@ export interface ManagedFunctionLoader {
 }
 
 export interface ManagedFunctionSelection {
-  readonly guest: Effect.Success<ReturnType<typeof buildManagedReleaseGraph>>;
-  readonly release: ManagedExecution["release"];
+  readonly guest: BundledGuest;
+  readonly platform: ManagedExecution["platform"];
   readonly requirements: ManagedExecution["requirements"];
 }
 
@@ -70,18 +69,14 @@ export const createManagedFunctionLoader = Effect.fn("ManagedFunctions.createLoa
     ["ignotum/internal/server", internalServerNamespace],
     ["ignotum/internal/api", apiNamespace],
   ]);
-  const guest = yield* validateManagedReleaseGraph(
-    selection.guest.manifestBytes,
-    [...selection.guest.files].map(([path, bytes]) => ({ path, bytes })),
-  );
+  const guest = selection.guest;
   const bridges = new Map<string, string>();
   for (const [specifier, namespace] of namespaces) {
-    const entry = guest.manifest.modules.find(
-      (module) => module.path === guest.manifest.entries[specifier],
-    );
-    if (entry === undefined || entry.exports.some((name) => !Object.hasOwn(namespace, name))) {
+    const entry = guest.manifest.entries[specifier];
+    if (entry === undefined || guest.sources[entry] === undefined) {
       throw new Error(`The local SDK cannot supply managed entry ${specifier}.`);
     }
+    const exports = Object.keys(namespace);
     const filename = path.join(directory, `${encodeURIComponent(specifier)}.mjs`);
     const key = Symbol.for(filename);
     // A facade captures the existing SDK namespace so schemas and codecs retain their owner.
@@ -94,7 +89,7 @@ export const createManagedFunctionLoader = Effect.fn("ManagedFunctions.createLoa
         Effect.gen(function* () {
           const source =
             `const namespace = globalThis[Symbol.for(${literal(filename)})];\n` +
-            entry.exports
+            exports
               .map(
                 (name, index) =>
                   `const binding${index} = namespace[${literal(name)}]; export { binding${index} as ${name} };`,
@@ -122,12 +117,9 @@ export const createManagedFunctionLoader = Effect.fn("ManagedFunctions.createLoa
           artifacts: build.artifacts,
           bytes: build.bytes,
           entry: build.server.schema.entry,
-          release: selection.release,
+          platform: selection.platform,
           requirements: selection.requirements,
-          guest: {
-            manifestBytes: selection.guest.manifestBytes,
-            files: [...selection.guest.files].map(([path, bytes]) => ({ path, bytes })),
-          },
+          guest,
         },
         "schema",
       ).pipe(Effect.provideService(Crypto.Crypto, crypto));

package/src/dev-runtime/managed-sync.ts

@@ -1,8 +1,9 @@
 import { canonicalInvocationInput } from "@ignotum/contracts/runtime/hosted";
+import { VersionId } from "@ignotum/contracts/runtime/identity";
 import { ManagedClientMessage, ManagedServerMessage } from "@ignotum/contracts/managed-sync";
 import {
-  sameExecutionSelection,
-  ExecutionSelection,
+  sameSelection,
+  ServingSelection,
   type RecoveryIdentity,
   type RecoverySessionId,
 } from "@ignotum/contracts/platform";
@@ -15,7 +16,8 @@ import { LocalApplicationFiles } from "./files.js";
 import { MutationReplay, QueryInvalidation, createLocalSession } from "./sync.js";
 
 export interface ManagedSyncOptions {
-  readonly selection: () => ExecutionSelection;
+  readonly selection: () => ServingSelection;
+  readonly versionId?: VersionId;
   readonly loadModule?: ViteDevServer["ssrLoadModule"];
   readonly isServerDependency?: (file: string) => boolean;
   readonly beforeReload?: (file: string, event: "add" | "change" | "unlink") => Promise<void>;
@@ -37,7 +39,7 @@ export const runManagedSession = Effect.fn("ManagedLocalSync.runSession")(functi
   const write = yield* socket.writer;
   const writes = yield* Semaphore.make(1);
   const messages = yield* Semaphore.make(1);
-  let selection: ExecutionSelection | undefined;
+  let selection: ServingSelection | undefined;
   let session: Effect.Success<ReturnType<typeof createLocalSession>> | undefined;
   let clientSessionId: RecoverySessionId | undefined;
   let expired = false;
@@ -69,8 +71,7 @@ export const runManagedSession = Effect.fn("ManagedLocalSync.runSession")(functi
   });
   const checkSelection = Effect.fn("ManagedLocalSync.checkSelection")(function* () {
     if (expired) return false;
-    if (selection === undefined || sameExecutionSelection(selection, options.selection()))
-      return true;
+    if (selection === undefined || sameSelection(selection, options.selection())) return true;
     expired = true;
     yield* send({ type: "UpgradeRequired", selection: options.selection() });
     yield* close;
@@ -107,12 +108,12 @@ export const runManagedSession = Effect.fn("ManagedLocalSync.runSession")(functi
     }>`SELECT input, prepared, clientSessionId, sessionEpoch, selection FROM managed_invocation_owners WHERE id = ${invocationId}`;
   const owns = (
     row: { clientSessionId: string; sessionEpoch: string; selection: string },
-    original: ExecutionSelection,
+    original: ServingSelection,
   ) =>
     row.clientSessionId === clientSessionId &&
     row.sessionEpoch === identity.sessionEpoch &&
-    sameExecutionSelection(
-      Schema.decodeSync(Schema.fromJsonString(ExecutionSelection))(row.selection),
+    sameSelection(
+      Schema.decodeSync(Schema.fromJsonString(ServingSelection))(row.selection),
       original,
     );
   const outcome = Effect.fn("ManagedLocalSync.outcome")(function* (
@@ -167,17 +168,16 @@ export const runManagedSession = Effect.fn("ManagedLocalSync.runSession")(functi
             if (selection !== undefined)
               return yield* error("InvalidMessage", "Connect has already been accepted.");
             const current = options.selection();
-            if (
-              message.protocolVersion !== 1 ||
-              !sameExecutionSelection(message.selection, current)
-            ) {
+            if (message.protocolVersion !== 1 || !sameSelection(message.selection, current)) {
               yield* send({ type: "UpgradeRequired", selection: current });
               return;
             }
             if (!(yield* checkIdentity())) return;
             selection = current;
             clientSessionId = message.clientSessionId;
-            session = yield* createLocalSession(current, identity, deliver);
+            const versionId =
+              options.versionId ?? VersionId.make(`dep_${current.appId.slice("app_".length)}`);
+            session = yield* createLocalSession(current, versionId, identity, deliver);
             yield* send({
               type: "Handshake",
               protocolVersion: 1,
@@ -195,7 +195,7 @@ export const runManagedSession = Effect.fn("ManagedLocalSync.runSession")(functi
             return yield* outcome(message.id, message.identity);
           if (message.type === "Invoke" || message.type === "Prepare") {
             const input = canonicalInvocationInput(
-              selection.versionId,
+              options.versionId ?? VersionId.make(`dep_${selection.appId.slice("app_".length)}`),
               "Mutation",
               message.function,
               message.args,
@@ -218,7 +218,7 @@ export const runManagedSession = Effect.fn("ManagedLocalSync.runSession")(functi
                 message.invocationId,
               );
             const encodedSelection = yield* Schema.encodeEffect(
-              Schema.fromJsonString(ExecutionSelection),
+              Schema.fromJsonString(ServingSelection),
             )(selection).pipe(Effect.orDie);
             const inserted =
               yield* sql`INSERT OR IGNORE INTO managed_invocation_owners (id, input, prepared, clientSessionId, sessionEpoch, selection) VALUES (${message.invocationId}, ${input}, ${message.type === "Prepare" ? 1 : 0}, ${clientSessionId!}, ${identity.sessionEpoch}, ${encodedSelection}) RETURNING id`.pipe(

package/src/dev-runtime/sync.ts

@@ -26,7 +26,8 @@ import {
   canonicalQueryKey,
 } from "@ignotum/contracts/runtime/hosted";
 import { SubscriptionId, type FunctionAddress } from "@ignotum/contracts/runtime/sync";
-import type { ExecutionSelection } from "@ignotum/contracts/platform";
+import type { VersionId } from "@ignotum/contracts/runtime/identity";
+import type { ServingSelection } from "@ignotum/contracts/platform";
 import {
   Effect,
   Clock,
@@ -216,7 +217,8 @@ const syncError = (code: LocalErrorCode, message: string, id: string): ManagedSe
 
 /** Executes admitted session commands directly; the transport owns framing and selection checks. */
 export const createLocalSession = Effect.fn("LocalSession.create")(function* (
-  selection: ExecutionSelection,
+  selection: ServingSelection,
+  versionId: VersionId,
   identity: SessionState,
   send: (message: ManagedServerMessage) => Effect.Effect<void, Socket.SocketError>,
 ) {
@@ -405,7 +407,7 @@ export const createLocalSession = Effect.fn("LocalSession.create")(function* (
       args: message.args,
       function: message.function,
       grantId: yield* ids.generate(SubscriptionId),
-      queryKey: canonicalQueryKey(selection.versionId, message.function, message.args),
+      queryKey: canonicalQueryKey(versionId, message.function, message.args),
       refreshGeneration: 0,
     };
     yield* Ref.update(subscriptions, HashMap.set(message.id, subscription));
@@ -449,7 +451,7 @@ export const createLocalSession = Effect.fn("LocalSession.create")(function* (
     }
 
     const input = canonicalInvocationInput(
-      selection.versionId,
+      versionId,
       "Mutation",
       message.function,
       message.args,

package/src/internal/api.ts

@@ -1,156 +1 @@
-import { Predicate } from "effect";
-import type { Effect } from "effect";
-
-import type { ErrorValue, InternalServerError } from "@ignotum/contracts/runtime/result";
-import { FunctionAddress } from "@ignotum/contracts/runtime/sync";
-import type { FileValue } from "@ignotum/contracts/schema/file";
-
-const FunctionReferenceTypeId: unique symbol = Symbol.for("ignotum/internal/api/FunctionReference");
-declare const FunctionReferenceTypesTypeId: unique symbol;
-
-type FunctionKind = "Mutation" | "Query";
-
-export type MutationInput<Value> = Value extends FileValue
-  ? Value | File
-  : Value extends Date
-    ? Value
-    : Value extends ReadonlyArray<infer Item>
-      ? ReadonlyArray<MutationInput<Item>>
-      : Value extends object
-        ? { readonly [Key in keyof Value]: MutationInput<Value[Key]> }
-        : Value;
-
-export interface FunctionReference<
-  Kind extends FunctionKind,
-  Args,
-  Success,
-  Failure extends ErrorValue,
-> {
-  readonly [FunctionReferenceTypeId]: FunctionAddress;
-  readonly [FunctionReferenceTypesTypeId]?: {
-    readonly kind: Kind;
-    readonly args: Args;
-    readonly value: Success;
-    readonly error: Failure;
-  };
-}
-
-type ReferenceTypes<Reference> = Reference extends {
-  readonly [FunctionReferenceTypesTypeId]?: infer Types;
-}
-  ? Exclude<Types, undefined>
-  : never;
-
-export declare namespace FunctionReference {
-  type Args<Reference> =
-    ReferenceTypes<Reference> extends { readonly args: infer Args } ? Args : never;
-  type Failure<Reference> =
-    ReferenceTypes<Reference> extends {
-      readonly error: infer Failure;
-    }
-      ? Failure
-      : never;
-  type Kind<Reference> =
-    ReferenceTypes<Reference> extends { readonly kind: infer Kind } ? Kind : never;
-  type Success<Reference> =
-    ReferenceTypes<Reference> extends {
-      readonly value: infer Success;
-    }
-      ? Success
-      : never;
-}
-
-type ReferenceOf<Definition> = Definition extends {
-  readonly _tag: infer Kind extends FunctionKind;
-  readonly handler: (
-    ...arguments_: infer HandlerArguments
-  ) => Generator<infer Yielded, infer Success, never>;
-}
-  ? HandlerArguments extends readonly [infer _Context, ...infer Rest]
-    ? FunctionReference<
-        Kind,
-        Rest extends readonly [infer Args, ...ReadonlyArray<unknown>]
-          ? Kind extends "Mutation"
-            ? MutationInput<Args>
-            : Args
-          : void,
-        Success,
-        | (Yielded extends Effect.Effect<unknown, infer Failure extends ErrorValue, never>
-            ? Failure
-            : never)
-        | InternalServerError
-      >
-    : never
-  : never;
-
-type ApiModule<Module> = {
-  readonly [FunctionName in keyof Module as FunctionName extends string
-    ? ReferenceOf<Module[FunctionName]> extends never
-      ? never
-      : FunctionName
-    : never]: ReferenceOf<Module[FunctionName]>;
-};
-
-export type Api<Modules> = {
-  readonly [ModuleName in keyof Modules]: ApiModule<Modules[ModuleName]>;
-};
-
-export const functionPathOf = <
-  Kind extends FunctionKind,
-  Args,
-  Success,
-  Failure extends ErrorValue,
->(
-  reference: FunctionReference<Kind, Args, Success, Failure>,
-) => reference[FunctionReferenceTypeId];
-
-const makeModuleReference = (moduleName: string) => {
-  const references = new Map<string, object>();
-
-  return new Proxy(
-    {},
-    {
-      get: (_target, functionName) => {
-        if (!Predicate.isString(functionName)) {
-          return undefined;
-        }
-
-        const existing = references.get(functionName);
-        if (existing !== undefined) {
-          return existing;
-        }
-
-        const reference = {
-          [FunctionReferenceTypeId]: FunctionAddress.make(`api.${moduleName}.${functionName}`),
-        };
-        references.set(functionName, reference);
-        return reference;
-      },
-    },
-  );
-};
-
-export function createApi<Modules>(): Api<Modules>;
-export function createApi() {
-  const modules = new Map<string, object>();
-
-  return new Proxy(
-    {},
-    {
-      get: (_target, moduleName) => {
-        if (!Predicate.isString(moduleName)) {
-          return undefined;
-        }
-
-        const existing = modules.get(moduleName);
-        if (existing !== undefined) {
-          return existing;
-        }
-
-        const moduleReference = makeModuleReference(moduleName);
-        modules.set(moduleName, moduleReference);
-        return moduleReference;
-      },
-    },
-  );
-}
+export * from "@ignotum/platform/versions/1/common/api";

package/src/internal/client.ts

@@ -1,186 +1 @@
-import {
-  LayoutMetadata,
-  RouteDefinition,
-  StaticMetadata,
-  UrlValueDescriptor,
-  UrlScalarDescriptor,
-} from "@ignotum/contracts/app-definition";
-import type { Id } from "@ignotum/contracts/schema";
-import { Schema } from "effect";
-import type { ComponentChildren, ComponentType } from "preact";
-import type { RouteLocation } from "../client/routes.js";
-
-export { createImageSource } from "../client/image.js";
-
-declare const UrlValueTypeId: unique symbol;
-type Scalar = string | number | boolean;
-type RequiredDescriptor = Exclude<UrlValueDescriptor, { type: "optional" | "default" }>;
-type Mode = "required" | "optional" | "default";
-
-export interface UrlValue<
-  Value,
-  Kind extends "scalar" | "array" = "scalar" | "array",
-  Presence extends Mode = Mode,
-> {
-  readonly descriptor: UrlValueDescriptor;
-  readonly [UrlValueTypeId]?: {
-    readonly value: Value;
-    readonly kind: Kind;
-    readonly presence: Presence;
-  };
-}
-export interface RequiredUrlValue<Value, Kind extends "scalar" | "array"> extends UrlValue<
-  Value,
-  Kind,
-  "required"
-> {
-  default(value: Value): UrlValue<Value, Kind, "default">;
-}
-export type UrlFields = Readonly<Record<string, UrlValue<unknown>>>;
-export type PathFields = Readonly<
-  Record<
-    string,
-    UrlValue<unknown, "scalar", "required"> | UrlValue<readonly string[], "array", "required">
-  >
->;
-type ValueOf<Value> = Value extends UrlValue<infer Decoded> ? Decoded : never;
-type OptionalKeys<Fields extends UrlFields> = {
-  [Key in keyof Fields]: Fields[Key] extends UrlValue<
-    unknown,
-    "scalar" | "array",
-    "optional" | "default"
-  >
-    ? Key
-    : never;
-}[keyof Fields];
-export type DecodedFields<Fields extends UrlFields> = {
-  readonly [Key in keyof Fields]: Fields[Key] extends UrlValue<
-    unknown,
-    "scalar" | "array",
-    "optional"
-  >
-    ? ValueOf<Fields[Key]> | undefined
-    : ValueOf<Fields[Key]>;
-};
-export type InputFields<Fields extends UrlFields> = {
-  readonly [Key in Exclude<keyof Fields, OptionalKeys<Fields>>]: ValueOf<Fields[Key]>;
-} & { readonly [Key in OptionalKeys<Fields>]?: ValueOf<Fields[Key]> | undefined };
-
-const validateValue = Schema.decodeUnknownSync(UrlValueDescriptor);
-const required = <Value, Kind extends "scalar" | "array">(
-  descriptor: RequiredDescriptor,
-): RequiredUrlValue<Value, Kind> => {
-  const checked = validateValue(descriptor);
-  return {
-    descriptor: checked,
-    default: (value) => ({
-      descriptor: validateValue({ type: "default", value: checked, default: value }),
-    }),
-  };
-};
-
-export interface UrlValues<DataModel> {
-  string(): RequiredUrlValue<string, "scalar">;
-  id<Table extends Extract<keyof DataModel, string>>(
-    table: Table,
-  ): RequiredUrlValue<Id<Table>, "scalar">;
-  number(): RequiredUrlValue<number, "scalar">;
-  integer(): RequiredUrlValue<number, "scalar">;
-  boolean(): RequiredUrlValue<boolean, "scalar">;
-  literal<const Value extends Scalar>(value: Value): RequiredUrlValue<Value, "scalar">;
-  literals<const Values extends readonly [Scalar, ...Scalar[]]>(
-    ...values: Values
-  ): RequiredUrlValue<Values[number], "scalar">;
-  optional<Value, Kind extends "scalar" | "array">(
-    value: RequiredUrlValue<Value, Kind>,
-  ): UrlValue<Value, Kind, "optional">;
-  array<Value>(
-    value: RequiredUrlValue<Value, "scalar">,
-  ): RequiredUrlValue<readonly Value[], "array">;
-}
-
-export interface RouteErrorProps {
-  readonly error: unknown;
-  readonly retry: () => void;
-}
-export interface InvalidRouteProps {
-  readonly location: RouteLocation;
-  readonly issues: ReadonlyArray<{
-    readonly source: "params" | "searchParams";
-    readonly field?: string | undefined;
-    readonly message: string;
-  }>;
-}
-export interface PageDefinition<
-  Params extends PathFields | undefined = PathFields | undefined,
-  Search extends UrlFields = UrlFields,
-> extends StaticMetadata {
-  readonly params?: Params;
-  readonly searchParams?: Search;
-  readonly component: ComponentType<{
-    readonly params: Params extends PathFields
-      ? DecodedFields<Params>
-      : Readonly<Record<string, string | readonly string[]>>;
-    readonly searchParams: DecodedFields<Search>;
-  }>;
-  readonly error?: ComponentType<RouteErrorProps>;
-  readonly invalid?: ComponentType<InvalidRouteProps>;
-}
-export interface LayoutDefinition extends LayoutMetadata {
-  readonly component: ComponentType<{ readonly children: ComponentChildren }>;
-  readonly error?: ComponentType<RouteErrorProps>;
-  readonly invalid?: ComponentType<InvalidRouteProps>;
-  readonly notFound?: ComponentType<{ readonly location: RouteLocation }>;
-}
-
-export const bindSchema = <DataModel>() => {
-  const values: UrlValues<DataModel> = {
-    string: () => required({ type: "string" }),
-    id: (table) => required({ type: "id", table }),
-    number: () => required({ type: "number" }),
-    integer: () => required({ type: "integer" }),
-    boolean: () => required({ type: "boolean" }),
-    literal: (value) => required({ type: "literal", value }),
-    literals: (...values) => required({ type: "literals", values }),
-    optional: (value) => ({
-      descriptor: validateValue({ type: "optional", value: value.descriptor }),
-    }),
-    array: (value) =>
-      required({
-        type: "array",
-        value: Schema.decodeUnknownSync(UrlScalarDescriptor)(value.descriptor),
-      }),
-  };
-  const route = <
-    const Params extends PathFields | undefined = undefined,
-    const Search extends UrlFields = {},
-  >(
-    definition: PageDefinition<Params, Search>,
-  ): PageDefinition<Params, Search> => {
-    Schema.decodeUnknownSync(StaticMetadata)({ title: definition.title, meta: definition.meta });
-    const params: PathFields = definition.params ?? {};
-    Schema.decodeUnknownSync(RouteDefinition.fields.params)(
-      Object.entries(params).map(([name, value]) => ({
-        name,
-        value: value.descriptor,
-      })),
-    );
-    for (const value of Object.values(definition.searchParams ?? {}))
-      validateValue(value.descriptor);
-    return definition;
-  };
-  const layout = (definition: LayoutDefinition): LayoutDefinition => {
-    Schema.decodeUnknownSync(LayoutMetadata)({
-      title: definition.title,
-      titleTemplate: definition.titleTemplate,
-      meta: definition.meta,
-    });
-    return definition;
-  };
-  return { route, layout, values };
-};
-
-export { createRouteReference, getRouteDefinition } from "./routes.js";
-
-export { mountClient } from "../client/bootstrap.js";
-export type { ClientRegistration, RegisteredClientModule } from "../client/router-store.js";
+export * from "@ignotum/platform/versions/1/browser/internal/client";

package/src/internal/host.ts

@@ -1 +1 @@
-export { evolve, invoke } from "@ignotum/runtime/guest";
+export * from "@ignotum/platform/versions/1/guest/internal/host";

package/src/internal/http-paths.ts

@@ -1,4 +1 @@
-export const ignotumPathPrefix = "/_ignotum";
-
-export const isIgnotumPath = (pathname: string): boolean =>
-  pathname === ignotumPathPrefix || pathname.startsWith(`${ignotumPathPrefix}/`);
+export * from "@ignotum/platform/versions/1/common/http-paths";

package/src/internal/routes.ts

@@ -1,45 +1 @@
-import { RouteDefinition } from "@ignotum/contracts/app-definition";
-import { Schema } from "effect";
-
-import type { DecodedFields, InputFields, PathFields, UrlFields } from "./client.js";
-
-const RouteReferenceTypeId: unique symbol = Symbol.for("ignotum/internal/routes/RouteReference");
-declare const RouteReferenceTypesTypeId: unique symbol;
-
-export interface RouteReference<Params = unknown, Search = unknown, SearchInputs = unknown> {
-  readonly [RouteReferenceTypeId]: RouteDefinition;
-  readonly [RouteReferenceTypesTypeId]?: {
-    readonly params: Params;
-    readonly searchParams: Search;
-    readonly searchInputs: SearchInputs;
-  };
-}
-export type ReferenceTypes<Reference> =
-  Reference extends RouteReference<infer Params, infer Search, infer SearchInputs>
-    ? {
-        readonly params: Params;
-        readonly searchParams: Search;
-        readonly searchInputs: SearchInputs;
-      }
-    : never;
-type ParamsOf<Page, Inferred> = Page extends { readonly params?: infer Params }
-  ? Params extends PathFields
-    ? DecodedFields<Params>
-    : Inferred
-  : Inferred;
-type SearchOf<Page> = Page extends { readonly searchParams?: infer Search extends UrlFields }
-  ? Search
-  : {};
-
-export const createRouteReference = <Page, InferredParams>(
-  definition: typeof RouteDefinition.Encoded,
-): RouteReference<
-  ParamsOf<Page, InferredParams>,
-  DecodedFields<SearchOf<Page>>,
-  InputFields<SearchOf<Page>>
-> => ({
-  [RouteReferenceTypeId]: Schema.decodeUnknownSync(RouteDefinition)(definition),
-});
-
-export const getRouteDefinition = (reference: RouteReference): RouteDefinition =>
-  reference[RouteReferenceTypeId];
+export * from "@ignotum/platform/versions/1/browser/internal/routes";

package/src/internal/server.ts

@@ -1,3 +1 @@
-import { bindSchema as bindContractSchema } from "@ignotum/contracts/schema";
-
-export const bindSchema: typeof bindContractSchema = bindContractSchema;
+export * from "@ignotum/platform/versions/1/guest/internal/server";

package/src/internal/types.ts

@@ -1,2 +1 @@
-export { SchemaDefinitionTypeId } from "@ignotum/contracts/schema";
-export type { Document, Id, SchemaDefinitionOf } from "@ignotum/contracts/schema";
+export * from "@ignotum/platform/versions/1/common/types";

package/src/server/index.ts

@@ -1,27 +1 @@
-import { Result as contractResult } from "@ignotum/contracts/runtime/result";
-import type { ErrorValue, Result as ContractResult } from "@ignotum/contracts/runtime/result";
-import {
-  defineEnv as defineContractEnv,
-  defineSchema as defineContractSchema,
-  Secret as contractSecret,
-} from "@ignotum/contracts/schema";
-import type { Secret as ContractSecret } from "@ignotum/contracts/schema";
-
-export const Result: typeof contractResult = contractResult;
-export type Result<Success, Failure extends ErrorValue> = ContractResult<Success, Failure>;
-export const defineEnv: typeof defineContractEnv = defineContractEnv;
-export const defineSchema: typeof defineContractSchema = defineContractSchema;
-export const Secret: typeof contractSecret = contractSecret;
-export type Secret<Value> = ContractSecret<Value>;
-export type {
-  DefinedEnv,
-  DefinedSchema,
-  EnvironmentAuthoring,
-  FileFormat,
-  FileMetadata,
-  FileMimeType,
-  FileValue,
-  SchemaAuthoring,
-} from "@ignotum/contracts/schema";
-
-export type { User, UserId } from "@ignotum/contracts/id";
+export * from "@ignotum/platform/versions/1/guest/server/index";