@astrale-os/sdk 0.1.10 → 0.2.0

package/src/config/define-domain.ts

@@ -1,7 +1,7 @@
 /**
  * `defineDomain` — the WORKER-SAFE definition of a domain: what the domain *is*
- * (its `schema`, `methods`, `deps`, `views`, standalone `functions`, `client`
- * SPA) plus its addressing identity (`origin`, `requires`, `postInstall`). It
+ * (its `schema`, `methods`, `deps`, `views`, standalone `functions`) plus its
+ * addressing identity (`origin`, `requires`, `postInstall`). It
  * deliberately carries NO deployment adapter — the adapter (`cloudflare(...)`,
  * `astrale(...)`) is node-only code (filesystem, wrangler) that must never enter
  * the worker bundle. The author wires this in a `domain.ts` the generated worker
@@ -11,14 +11,14 @@
  * The modules are wired EXPLICITLY here — imported and passed in — not
  * discovered from magic folder names. A renamed or mistyped module is a compile
  * error at this call site, never a silently-missing worker route. The adapter
- * reads this one definition for everything it codegens; there is no second
- * filesystem probe to drift from it. `defineDomain` itself builds no server and
- * boots no kernel — it validates and packages the declaration.
+ * reads this one definition for domain-side codegen; frontend source folders
+ * live in adapter env config. `defineDomain` itself builds no server and boots
+ * no kernel — it validates and packages the declaration.
  */
 
 import type { Schema } from '@astrale-os/kernel-dsl'
 
-import { DomainOrigin, extractDomainSlug } from '@astrale-os/kernel-core/domain'
+import { DomainOrigin } from '@astrale-os/kernel-core/domain'
 
 import type { RemoteFunctionDef, ViewDef } from '../define'
 import type { SchemaMethodsImpl } from '../method'
@@ -33,15 +33,6 @@ type AnyViewDef = ViewDef<any>
 type AnyFunctionDef = RemoteFunctionDef<any, any, any>
 // oxlint-enable no-explicit-any
 
-/**
- * The domain's client SPA binding. Its presence is the whole signal — there is
- * no `existsSync('client/')` probe. `dir` is the project-relative source folder
- * (e.g. `'client'`); the worker serves its built SPA under `/ui` via its Assets
- * binding. Always written out explicitly (`client: { dir: 'client' }`) — there
- * is no boolean shorthand, so the source folder is never implicit.
- */
-export type ClientBinding = { dir: string }
-
 export interface DefineDomainConfig<S extends Schema, TDeps, TEnv = unknown> {
   /** The domain schema (from `schema/`). Its `.domain` seeds the default origin. */
   schema: S
@@ -76,12 +67,6 @@ export interface DefineDomainConfig<S extends Schema, TDeps, TEnv = unknown> {
    * by slug. Omit when the domain has none.
    */
   functions?: Record<string, AnyFunctionDef>
-  /**
-   * The domain's client SPA, e.g. `{ dir: 'client' }`. Its presence enables it
-   * (no folder probing); `dir` is the project-relative source folder, built and
-   * served under `/ui`. Omit for a domain with no SPA.
-   */
-  client?: ClientBinding
   /**
    * The domain's **addressing name** (the graph slug it mounts under, e.g.
    * `'crm.acme.dev'`). Defaults to `schema.domain`. Must be a name, never a
@@ -94,11 +79,15 @@ export interface DefineDomainConfig<S extends Schema, TDeps, TEnv = unknown> {
   /** Cross-domain deps, by origin. Verified present on the instance at install. */
   requires?: readonly string[]
   /**
-   * Astrale Path (usually an AbsolutePath to a `functions/` entry) the kernel
-   * calls once after install, as __SYSTEM__ — where the domain posts its own
-   * grants / seed.
+   * The function the kernel runs once after install, as __SYSTEM__ — where the
+   * domain seeds itself / posts its own grants. Reference it from the `functions`
+   * map: `postInstall: functions.seed`. The SDK derives its path by identity, so a
+   * typo or a renamed key is a compile error here, never a stale string. It is
+   * always a standalone function (a domain bootstrap belongs to the domain, not to
+   * a class) under THIS domain — you never write the origin, and the kernel
+   * resolves it relative to wherever the domain is installed.
    */
-  postInstall?: string
+  postInstall?: AnyFunctionDef
 }
 
 export interface DomainDefinition {
@@ -114,8 +103,6 @@ export interface DomainDefinition {
   deps?: (env: any, url: string) => any
   views?: Record<string, ViewDef>
   functions?: Record<string, AnyFunctionDef>
-  /** Normalized client binding (resolved `dir`), or absent when the domain has no SPA. */
-  client?: { dir: string }
   origin: string
   requires: readonly string[]
   postInstall?: string
@@ -170,46 +157,37 @@ export function defineDomain<S extends Schema, TDeps, TEnv = unknown>(
     ...(config.deps ? { deps: config.deps as DomainDefinition['deps'] } : {}),
     ...(config.views ? { views: config.views as Record<string, ViewDef> } : {}),
     ...(config.functions ? { functions: config.functions } : {}),
-    ...(config.client ? { client: config.client } : {}),
     origin,
     requires,
-    ...(config.postInstall
-      ? { postInstall: normalizePostInstall(config.postInstall, origin) }
+    ...(config.postInstall !== undefined
+      ? { postInstall: normalizePostInstall(config.postInstall, origin, config.functions) }
       : {}),
   }
 }
 
 /**
- * Validate a `postInstall` hook path and align its leading origin segment with
- * the canonical (lowercased) origin. Only the typed colon forms are accepted
- * (`/:<origin>:class.X:seed`, `/:<origin>:interface.Ops:seed`) — mirroring the
- * kernel's own origin guard, which refuses absolute tree paths because they
- * cannot prove their origin from the string alone. The hook is often authored
- * as `` `/:${schema.domain}:…` `` where `schema.domain` keeps its source
- * casing, but the kernel stores graph nodes (and runs its guard) under the
- * lowercased origin — so the origin segment is re-stamped canonical. Rejects a
- * tree path or one pointing at a different domain (the kernel calls the hook
- * as __SYSTEM__ and refuses a foreign target).
+ * Resolve a `postInstall` function reference to the colon-path the bundle carries.
+ * The slug is the `functions` map key the reference is registered under (found by
+ * identity), so a renamed key is a compile error at the reference site AND the
+ * derived path follows the rename. The origin is never the author's to supply
+ * (postInstall is always a standalone function of THIS domain) and the path is
+ * mount-agnostic — the kernel resolves it wherever the domain is installed.
  */
-function normalizePostInstall(postInstall: string, origin: string): string {
-  const slug = extractDomainSlug(postInstall)
-  if (slug === null) {
-    throw new Error(
-      `defineDomain: \`postInstall\` must be a typed colon-path under "/:${origin}" ` +
-        `(e.g. "/:${origin}:class.Note:seed" or "/:${origin}:interface.Ops:seed"); ` +
-        `absolute tree paths are not accepted — got "${postInstall}".`,
-    )
-  }
-  if (slug.toLowerCase() !== origin) {
+function normalizePostInstall(
+  postInstall: AnyFunctionDef,
+  origin: string,
+  functions: Record<string, AnyFunctionDef> | undefined,
+): string {
+  const slug = functions
+    ? Object.entries(functions).find(([, def]) => def === postInstall)?.[0]
+    : undefined
+  if (slug === undefined) {
     throw new Error(
-      `defineDomain: \`postInstall\` "${postInstall}" must resolve under the domain origin ` +
-        `"/${origin}" — the kernel calls it as __SYSTEM__ and refuses a hook pointing at another domain.`,
+      "defineDomain: `postInstall` must reference a function from this domain's `functions` map " +
+        '(e.g. `postInstall: functions.seed`).',
     )
   }
-  // Re-stamp the origin segment with its canonical (lowercased) form.
-  return postInstall.startsWith('/:')
-    ? `/:${origin}${postInstall.slice(2 + slug.length)}`
-    : `/${origin}${postInstall.slice(1 + slug.length)}`
+  return `/:${origin}:function.${slug}`
 }
 
 function schemaDomain(schema: Schema): string | undefined {

package/src/config/deploy.ts

@@ -9,7 +9,7 @@
  * is authored in `astrale.config.ts` — a Node-only module the CLI loads but the
  * worker never imports — so the adapter stays out of the bundle.
  *
- *   export const domain = defineDomain({ schema, methods, deps, views, client })
+ *   export const domain = defineDomain({ schema, methods, deps, views })
  *
  *   import { domain } from './domain'
  *   export default deploy(domain, cloudflare({ dev, prod }))

package/src/config/index.ts

@@ -14,7 +14,7 @@
  */
 
 export { defineDomain } from './define-domain'
-export type { ClientBinding, DefineDomainConfig, DomainDefinition } from './define-domain'
+export type { DefineDomainConfig, DomainDefinition } from './define-domain'
 
 export { deploy } from './deploy'
 export type { DeployConfig } from './deploy'

package/src/define/remote-function.ts

@@ -4,16 +4,17 @@
  * the canonical kernel `Function` class, the former distribution `RemoteFunction`.)
  *
  * Each entry in `defineRemoteDomain({ remoteFunctions: { ... } })` becomes:
- *   - a graph node at `/${origin}/core/<functionsFolder>/<slug>`, materialized
- *     as the kernel `Function` class by `buildCorePath` so kernel discovery /
- *     `View.resolve` can list it. The `core/` anchor appears in the GRAPH path only.
+ *   - a graph node at `/${origin}/functions/<slug>` — a first-class domain MEMBER,
+ *     materialized as the kernel `Function` class and attached to the Domain via an
+ *     `of_domain` edge (slug `function.<slug>`), so it is addressable by the
+ *     semantic path `/:${origin}:function.<slug>` (the form a `postInstall` uses).
  *   - a Hono route on the worker at the path implied by `binding`
- *     (`/<functionsFolder>/<slug>` POST by default — no `core/` in the URL).
+ *     (`/<functionsFolder>/<slug>` POST by default — the route URL is decoupled
+ *     from the graph layout).
  *
- * The slug = the map key (single source of truth, no duplication).
- *
- * `ref` is auto-derived as `function.<slug>` if omitted — used as
- * `Function.ref` on the graph node and as the dispatch key.
+ * The slug = the map key (single source of truth, no duplication). The member
+ * ref (`function.<slug>`), the layout (`/<origin>/functions/<slug>`), and the
+ * `of_domain` edge slug are all DERIVED from it — there is nothing else to name.
  */
 
 import type { AuthPolicy, FunctionBinding } from '@astrale-os/kernel-api/routed'
@@ -77,12 +78,6 @@ export type RemoteFunctionDef<
   TDeps = unknown,
   TAuth extends AuthPolicy = 'required',
 > = {
-  /**
-   * Canonical callable identity. Auto-derived as `function.<slug>` (where
-   * `<slug>` is the map key) when omitted. Stored as `Function.ref` on the
-   * graph node and used by the kernel dispatcher to route the call.
-   */
-  ref?: string
   /** Zod schema for the call's parameters. */
   inputSchema: z.ZodType<TParams>
   /** Zod schema for the call's result. */

package/src/define/view.ts

@@ -2,14 +2,16 @@
  * Authoring a `View` — iframe-mountable callable served by the domain worker.
  *
  * Each entry in `defineRemoteDomain({ views: { ... } })` becomes both:
- *   - a graph node at `/${origin}/core/<viewsFolder>/<slug>` (auto-materialized
- *     by the SDK; the `core/` segment is the universal anchor injected by
- *     `buildCorePath`. `<slug>` is the map key, so it lives in exactly one place)
+ *   - a first-class domain MEMBER: a `View` node at `/${origin}/views/<slug>`
+ *     attached to the Domain via an `of_domain` edge (slug `view.<slug>`),
+ *     addressable as `/:${origin}:view.<slug>`. `<slug>` is the map key, so it
+ *     lives in exactly one place.
  *   - a Hono route on the worker at the path implied by `binding`
- *     (`/<viewsFolder>/<slug>` by default — note: no `core/` in the URL).
+ *     (`/<viewsFolder>/<slug>` by default).
  *
- * The `core/` segment appears in the GRAPH path only; the URL path that
- * lands in `Function.binding.remoteUrl` is `${url}/<viewsFolder>/<slug>`.
+ * The graph layout (`/<origin>/views/<slug>`) is a fixed kernel convention; the
+ * URL path that lands in `Function.binding.remoteUrl` is
+ * `${url}/<viewsFolder>/<slug>` — DECOUPLED from the graph layout.
  *
  * The author can override the URL via `binding` — host and/or path
  * placeholders are supported (the kernel's `route` mechanism does the

package/src/dispatch/identity.ts

@@ -1,10 +1,10 @@
 /**
  * Per-callable identity — dispatcher runtime + install-time wiring.
  *
- * Two flavors of callable get an identity per the install-time identity
- * binding: Methods on classes/interfaces (sub = MethodPath) and auto-
- * materialized core function nodes — RemoteFunctions and Views (sub =
- * AbsolutePath of the node under `core/{functions,views}/<slug>`).
+ * Three flavors of callable get an identity per the install-time identity
+ * binding: Methods on classes/interfaces (sub = MethodPath), standalone-function
+ * MEMBERS (sub = AbsolutePath at `/<origin>/functions/<slug>`), and view MEMBERS
+ * (sub = AbsolutePath at `/<origin>/views/<slug>`).
  *
  * At server startup the method dispatcher and the View / RemoteFunction
  * route mounter pre-compute, for every materialized callable, the
@@ -54,11 +54,12 @@ export type AuxBuckets<T> = {
 }
 
 /**
- * slug → `AbsolutePath.raw` for each auto-materialized aux node
- * (RemoteFunction / View). These nodes live at
- * `/<origin>/core/{functions,views}/<slug>` and have no class+method
- * decomposition that would justify a MethodPath — their identity is their
- * graph position.
+ * slug → `AbsolutePath.raw` for each aux callable MEMBER node:
+ *   - standalone-function members (`kind: 'function'`) at `/<origin>/functions/<slug>`;
+ *   - view members (`kind: 'view'`) at `/<origin>/views/<slug>` (plus any
+ *     hand-authored/legacy core `View` nodes, `kind: 'core'` className `View`).
+ * Neither has a class+method decomposition that would justify a MethodPath —
+ * their identity is their graph position.
  */
 export type AuxIdentityPaths = AuxBuckets<string>
 
@@ -66,20 +67,13 @@ export function collectAuxIdentityPaths(compiled: CompiledDomain): AuxIdentityPa
   const views: Record<string, string> = {}
   const remoteFunctions: Record<string, string> = {}
   for (const c of resolveCallables(compiled)) {
-    if (c.kind !== 'core' || !c.slug) continue
-    if (c.className === 'View') {
-      views[c.slug] = c.sub
-    } else if (c.className === 'Function') {
-      // Standalone callables (the former `RemoteFunction`) materialize as the
-      // canonical kernel `Function` class.
+    if (!c.slug) continue
+    if (c.kind === 'function') {
       remoteFunctions[c.slug] = c.sub
-    } else {
-      throw new Error(
-        `collectAuxIdentityPaths: unrecognised aux callable className "${c.className}" ` +
-          `at ${c.ref}. If you've added a new auto-materialized Function class to extendCore, ` +
-          `extend this collector + the kernel walker (resolveCallables) to handle it.`,
-      )
+    } else if (c.kind === 'view' || (c.kind === 'core' && c.className === 'View')) {
+      views[c.slug] = c.sub
     }
+    // Methods (`kind: 'method'`) get their identity via `collectMethodPaths`.
   }
   return { views, remoteFunctions }
 }

package/src/domain/binding.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared binding helpers for auto-materialized members (functions + views).
+ *
+ * The worker ROUTE URL a member is served at — `<url>/<folderSlug>/<slug>` — is
+ * decoupled from the member's GRAPH layout (`/<origin>/{functions,views}/<slug>`,
+ * a fixed kernel convention). `folderSlug` names only the URL segment.
+ */
+
+import type { FunctionBinding } from '@astrale-os/kernel-api/routed'
+
+/** Join a worker-relative mount path onto the serving url (single slash). */
+export function joinWorkerPath(url: string, mount: string): string {
+  const base = url.replace(/\/+$/, '')
+  return `${base}/${mount.replace(/^\/+/, '')}`
+}
+
+/**
+ * Resolve a member's effective binding against the serving `url`. An explicit
+ * `override.remoteUrl` wins; otherwise defaults to `<url>/<folderSlug>/<slug>`.
+ * Same trailing-slash discipline as {@link joinWorkerPath} — a `url` ending in
+ * `/` must not produce `//` (the kernel pins `iss` by exact string).
+ */
+export function resolveBinding(
+  override: FunctionBinding | undefined,
+  url: string,
+  folderSlug: string,
+  slug: string,
+): FunctionBinding {
+  const base = url.replace(/\/+$/, '')
+  if (override) {
+    return {
+      ...override,
+      remoteUrl: override.remoteUrl ?? `${base}/${folderSlug}/${slug}`,
+    }
+  }
+  return { remoteUrl: `${base}/${folderSlug}/${slug}` }
+}

package/src/domain/build-spec.ts

@@ -18,7 +18,7 @@
  */
 
 import type { Graph, WireGraph } from '@astrale-os/kernel-core'
-import type { BoundMethod, FunctionSchema } from '@astrale-os/kernel-core/domain'
+import type { BoundMethod, FunctionSchema, ViewSchema } from '@astrale-os/kernel-core/domain'
 import type { Schema } from '@astrale-os/kernel-dsl'
 
 import { hashInstallGraph, serialize, zodToJsonSchema } from '@astrale-os/kernel-core/domain'
@@ -41,8 +41,14 @@ export function buildInstallGraph<S extends Schema>(
   domain: RemoteDomain<S>,
   url: string,
 ): WireGraph {
-  const { compiled } = materializeRemoteDomain(domain, url)
-  return buildSpecInternal(compiled, domain.methods, url).toWire() as WireGraph
+  const { compiled, auxiliary } = materializeRemoteDomain(domain, url)
+  return buildSpecInternal(
+    compiled,
+    domain.methods,
+    url,
+    auxiliary?.functionSchemas ?? [],
+    auxiliary?.viewSchemas ?? [],
+  ).toWire() as WireGraph
 }
 
 /**
@@ -63,12 +69,17 @@ function buildSpecInternal(
   compiled: RemoteDomain['compiled'],
   methods: BoundMethod<AnyRemoteHandler>[],
   url: string,
+  functionSchemas: FunctionSchema[],
+  viewSchemas: ViewSchema[],
 ): Graph {
   const serialized = serializeMethodsWithStubs(compiled, methods, url)
-  const tree = serialize(compiled, serialized)
-  // Views / RemoteFunctions are auto-materialized into the Core BEFORE
-  // `compileDomain` runs (see `extend-core.ts`). By the time we reach
-  // `serialize` here the Tree already contains their nodes/edges.
+  // Method impls + standalone-function-member impls travel in the same callable
+  // array (distinct refs: `class.X.method.y` vs `function.<slug>`); view-member
+  // impls travel in `options.views` (a view differs structurally — handshake,
+  // view_for, View class). The serializer emits method nodes from the IR,
+  // function/view members from `compiled.$.refs.{functions,views}`, pulling each
+  // impl by ref.
+  const tree = serialize(compiled, [...serialized, ...functionSchemas], { views: viewSchemas })
   return tree.toGraph()
 }
 

package/src/domain/define.ts

@@ -1,14 +1,14 @@
 /**
  * `defineRemoteDomain` — turn a typed schema + methods map into a mountable domain.
  *
- * When `views` and/or `remoteFunctions` entries are provided, the SDK
- * auto-materializes graph nodes
- * under reserved folders (`viewsFolder` / `functionsFolder`, defaults `'views'`
- * / `'functions'`). Views and standalone functions materialize as canonical
- * kernel `View` / `Function` classes by default (no per-domain class to
- * configure). The same entries'
+ * `views` and `functions` entries become first-class DOMAIN MEMBERS: a `View` /
+ * `Function` node attached to the Domain via an `of_domain` edge (slug
+ * `view.<slug>` / `function.<slug>`), laid out at `/<origin>/{views,functions}/<slug>`.
+ * Their contract half (the member ref) threads through `compileDomain`; their
+ * impl/binding half threads through `serialize`. The same entries'
  * `render` / `execute` handlers are mounted as Hono routes by
- * `createRemoteServer`. Slug = map key.
+ * `createRemoteServer` at `<url>/<viewsFolder|functionsFolder>/<slug>` (the route
+ * URL is decoupled from the graph layout). Slug = map key.
  *
  * The domain definition is deployment-agnostic: it carries NO serving url. The
  * url is supplied late by the spec producer (`createRemoteServer({ url })` at
@@ -18,8 +18,13 @@
  */
 
 import type { FunctionBinding } from '@astrale-os/kernel-api/routed'
-import type { BoundMethod, CompiledDomain } from '@astrale-os/kernel-core/domain'
-import type { AnyEdgeDef, AnyNodeDef, Core, Schema } from '@astrale-os/kernel-dsl'
+import type {
+  BoundMethod,
+  CompiledDomain,
+  FunctionSchema,
+  ViewSchema,
+} from '@astrale-os/kernel-core/domain'
+import type { Core, Schema } from '@astrale-os/kernel-dsl'
 
 import { bindMethods, compileDomain } from '@astrale-os/kernel-core/domain'
 
@@ -27,7 +32,12 @@ import type { AnyRemoteFunctionDef, ViewDef } from '../define'
 import type { SchemaMethodsImpl } from '../method/class'
 import type { AnyRemoteHandler } from '../method/single'
 
-import { DEFAULT_FUNCTIONS_FOLDER, DEFAULT_VIEWS_FOLDER, extendCore } from './extend-core'
+import {
+  buildFunctionDeclarations,
+  buildFunctionSchemas,
+  DEFAULT_FUNCTIONS_FOLDER,
+} from './extend-functions'
+import { buildViewDeclarations, buildViewSchemas, DEFAULT_VIEWS_FOLDER } from './extend-views'
 
 export type RemoteDomainConfig<S extends Schema, TDeps> = {
   schema: S
@@ -35,27 +45,29 @@ export type RemoteDomainConfig<S extends Schema, TDeps> = {
   core?: Core<S>
 
   views?: Record<string, ViewDef<TDeps>>
-  viewClass?: AnyNodeDef
-  viewForEdgeClass?: AnyEdgeDef
   viewsFolder?: string
 
   remoteFunctions?: Record<string, AnyRemoteFunctionDef>
   functionsFolder?: string
 }
 
-/** Effective bindings + folder layout for auxiliary routes, resolved against `url`. */
+/** Effective bindings + folder layout + member schemas for auxiliary routes, resolved against `url`. */
 export type AuxiliaryMetadata = {
   url: string
   viewsFolder: string
   functionsFolder: string
   viewBindings: Record<string, FunctionBinding>
   remoteFunctionBindings: Record<string, FunctionBinding>
+  /** Function members' impl/binding half (`function.<slug>`) for `serialize`. */
+  functionSchemas: FunctionSchema[]
+  /** View members' impl/binding half (`view.<slug>`) for `serialize`. */
+  viewSchemas: ViewSchema[]
 }
 
 export type RemoteDomain<S extends Schema = Schema> = {
   /**
-   * Define-time compile: full domain STRUCTURE (classes, methods, and the aux
-   * View/Function nodes' paths/names/refs — what identity, subs, and contract
+   * Define-time compile: full domain STRUCTURE (classes, methods, and the
+   * view/function members' paths/names/refs — what identity, subs, and contract
    * resolution need). It carries NO `binding` values: bindings derive from the
    * serving url, which only the spec producers know — they call
    * `materializeRemoteDomain(domain, url)` for the install-ready compile.
@@ -65,42 +77,32 @@ export type RemoteDomain<S extends Schema = Schema> = {
   // oxlint-disable-next-line no-explicit-any
   views?: Record<string, ViewDef<any>>
   remoteFunctions?: Record<string, AnyRemoteFunctionDef>
-  /** The original config, so `materializeRemoteDomain` re-extends from source. */
-  config: ExtendInputs
+  /** The original config, so `materializeRemoteDomain` re-materializes from source. */
+  config: MaterializeInputs
 }
 
-/** The defineRemoteDomain inputs `materializeRemoteDomain` needs to re-extend. */
-type ExtendInputs = {
+/** The defineRemoteDomain inputs `materializeRemoteDomain` needs to re-materialize. */
+type MaterializeInputs = {
   userCore?: Core
-  viewClass?: AnyNodeDef
-  viewForEdgeClass?: AnyEdgeDef
   viewsFolder: string
   functionsFolder: string
 }
 
 export function defineRemoteDomain<TDeps>() {
   return function <S extends Schema>(config: RemoteDomainConfig<S, TDeps>): RemoteDomain<S> {
-    const hasAux = Boolean(config.views || config.remoteFunctions)
     const viewsFolder = config.viewsFolder ?? DEFAULT_VIEWS_FOLDER
     const functionsFolder = config.functionsFolder ?? DEFAULT_FUNCTIONS_FOLDER
 
-    // Structure-only extension (no url → no bindings stamped): the aux nodes
-    // exist with their paths so subs/identity/contract resolution see them.
-    const effectiveCore: Core | undefined = hasAux
-      ? extendCore({
-          schema: config.schema,
-          origin: config.schema.domain,
-          userCore: config.core,
-          viewClass: config.viewClass,
-          viewForEdgeClass: config.viewForEdgeClass,
-          viewsFolder,
-          views: config.views,
-          functionsFolder,
-          remoteFunctions: config.remoteFunctions,
-        }).core
-      : config.core
-
-    const compiled = compileDomain(config.schema, effectiveCore as Core<S> | undefined)
+    // Views + functions are domain MEMBERS — their contract enters compile via
+    // the `functions` / `views` args (no Core involvement). `config.core` is the
+    // author's own genuine genesis instance data, untouched.
+    const compiled = compileDomain(
+      config.schema,
+      config.core,
+      undefined,
+      config.remoteFunctions ? buildFunctionDeclarations(config.remoteFunctions) : undefined,
+      config.views ? buildViewDeclarations(config.views) : undefined,
+    )
     const methods = bindMethods<AnyRemoteHandler>(
       compiled.$.schema,
       compiled.$.methods,
@@ -115,8 +117,6 @@ export function defineRemoteDomain<TDeps>() {
       ...(config.remoteFunctions ? { remoteFunctions: config.remoteFunctions } : {}),
       config: {
         userCore: config.core,
-        viewClass: config.viewClass,
-        viewForEdgeClass: config.viewForEdgeClass,
         viewsFolder,
         functionsFolder,
       },
@@ -125,13 +125,13 @@ export function defineRemoteDomain<TDeps>() {
 }
 
 /**
- * Materialize a `RemoteDomain` at its real serving `url`: re-runs `extendCore`
- * so every aux View/Function `binding.remoteUrl` points at the actual host,
- * and returns the binding maps the auxiliary routes mount from. Called by the
- * only two spec producers — `createRemoteServer` (`config.url`) and the
- * `astrale-domain` CLI. Returns the define-time `compiled` untouched when there is no aux to
- * stamp. `extendCore`/`compileDomain` are pure, so this is safe to call
- * repeatedly (and is memoized per cold isolate by the callers).
+ * Materialize a `RemoteDomain` at its real serving `url`: re-compiles the domain
+ * and builds every member's url-stamped impl schema + binding, returning the
+ * binding maps the auxiliary routes mount from and the member schemas `serialize`
+ * emits from. Called by the only two spec producers — `createRemoteServer`
+ * (`config.url`) and the `astrale-domain` CLI. Returns the define-time `compiled`
+ * untouched when there is no aux to stamp. Pure, so safe to call repeatedly (and
+ * memoized per cold isolate by the callers).
  */
 export function materializeRemoteDomain<S extends Schema>(
   domain: RemoteDomain<S>,
@@ -142,27 +142,32 @@ export function materializeRemoteDomain<S extends Schema>(
 
   const { config } = domain
   const schema = domain.compiled.$.schema as S
-  const result = extendCore({
+
+  const compiled = compileDomain(
     schema,
-    origin: schema.domain,
-    userCore: config.userCore,
-    url,
-    viewClass: config.viewClass,
-    viewForEdgeClass: config.viewForEdgeClass,
-    viewsFolder: config.viewsFolder,
-    views: domain.views,
-    functionsFolder: config.functionsFolder,
-    remoteFunctions: domain.remoteFunctions,
-  })
-  const compiled = compileDomain(schema, result.core as Core<S>)
+    config.userCore as Core<S> | undefined,
+    undefined,
+    domain.remoteFunctions ? buildFunctionDeclarations(domain.remoteFunctions) : undefined,
+    domain.views ? buildViewDeclarations(domain.views) : undefined,
+  )
+
+  const fns = domain.remoteFunctions
+    ? buildFunctionSchemas(domain.remoteFunctions, url, config.functionsFolder)
+    : { schemas: [], bindings: {} }
+  const vws = domain.views
+    ? buildViewSchemas(domain.views, url, config.viewsFolder, schema)
+    : { schemas: [], bindings: {} }
+
   return {
     compiled,
     auxiliary: {
       url,
       viewsFolder: config.viewsFolder,
       functionsFolder: config.functionsFolder,
-      viewBindings: result.viewBindings,
-      remoteFunctionBindings: result.remoteFunctionBindings,
+      viewBindings: vws.bindings,
+      remoteFunctionBindings: fns.bindings,
+      functionSchemas: fns.schemas,
+      viewSchemas: vws.schemas,
     },
   }
 }