@astrale-os/sdk 0.4.19 → 0.5.0-beta.2

package/src/cli/spec.ts

@@ -1,44 +0,0 @@
-/**
- * Build a diagnostic spec (wire graph + schema hash) from the project's
- * `defineDomain` definition. This mirrors what the codegen'd worker assembles —
- * but only for inspection / `/meta` provenance. The live install bundle is
- * always produced by the worker at request time, so a failure here is non-fatal
- * for dev/deploy (the CLI logs and continues) and fatal only for
- * `astrale-domain build`, where the spec IS the product.
- *
- * The modules (`schema` / `methods` / `views` / `functions`) come straight off
- * the definition — the SAME values the author wired into `defineDomain`, which
- * the adapter codegen also assembles. One source, no second filesystem probe to
- * drift from it.
- */
-
-import type { Schema } from '@astrale-os/kernel-dsl'
-
-import { hashInstallGraph } from '@astrale-os/kernel-core/domain'
-
-import type { DomainDefinition } from '../config/define-domain.js'
-import type { RemoteDomainConfig } from '../domain/index.js'
-
-import { buildInstallGraph, defineRemoteDomain } from '../domain/index.js'
-
-export async function buildProjectSpec(
-  def: DomainDefinition,
-  url: string,
-): Promise<{ wire: Record<string, unknown>; schemaHash: string }> {
-  // The definition's module values are untyped against `RemoteDomainConfig` by
-  // nature (deps/schema generics erased on `DomainDefinition`); funnel them
-  // through ONE cast into the config shape `defineRemoteDomain` validates.
-  const config = {
-    schema: def.schema,
-    methods: def.methods,
-    ...(def.core ? { core: def.core } : {}),
-    ...(def.views ? { views: def.views } : {}),
-    ...(def.functions ? { remoteFunctions: def.functions } : {}),
-    ...(def.path ? { path: def.path } : {}),
-  } as RemoteDomainConfig<Schema, unknown>
-
-  const domain = defineRemoteDomain<unknown>()(config)
-  const wire = buildInstallGraph(domain, url)
-  const schemaHash = await hashInstallGraph(wire)
-  return { wire: wire as unknown as Record<string, unknown>, schemaHash }
-}

package/src/config/adapter.ts

@@ -1,177 +0,0 @@
-/**
- * The deployment-adapter contract.
- *
- * A deployment target = one npm package implementing `DomainAdapter<Params>`.
- * The adapter is GENERIC over its own `Params` so envs AND provider settings
- * stay 100% adapter-specific (a Cloudflare adapter's `{ route, secrets }` is
- * nothing like a Node adapter's `{ port }`). The CLI resolves
- * `envs[<env>] → Params` via `adapter.params(env)` and then drives the adapter
- * with the resolved params — install of the resulting URL and the `requires`
- * check are generic and live in the CLI, never in the adapter.
- *
- * The central guarantee: `watch()` and `deploy()` both return a `url` — that's
- * what the CLI prints, what `astrale domain install <url>` consumes, and
- * the worker's `iss` identity. The URL is an OUTPUT of watch/deploy; nothing
- * in the contract asks an adapter to predict it ahead of time.
- */
-
-/**
- * Generic, target-independent domain metadata the CLI hands every adapter so
- * it can codegen the worker entry. (Extends the bare `WatchCtx`/`DeployCtx` of
- * the spec with the fields a real codegen needs.)
- */
-export interface DomainInfo {
-  /**
-   * The domain's addressing name — the graph slug it mounts under (e.g.
-   * `'crm.acme.dev'`). NOT the cryptographic identity: the JWT `iss` is the
-   * worker's serving URL, pinned by the kernel at install time.
-   */
-  origin: string
-  /** Cross-domain deps by origin — verified at install (CLI/kernel), not here. */
-  requires: readonly string[]
-  /** Optional Astrale Path called by the kernel after install (as __SYSTEM__). */
-  postInstall?: string
-  /**
-   * Whether the domain declares Views / standalone Functions — read from the
-   * `defineDomain` definition, NOT probed from the filesystem. The adapter
-   * codegen imports the corresponding module only when true.
-   */
-  hasViews: boolean
-  hasFunctions: boolean
-  /**
-   * Views whose binding is backed by a worker-relative SPA mount. This is domain
-   * contract metadata (`defineView({ mount })`), not a frontend source folder:
-   * adapters decide, per env, which client assets serve these mounts.
-   */
-  mountedViews: Array<{ slug: string; mount: string }>
-  /**
-   * Whether the domain declares a `deps` mapper (`defineDomain({ deps })`).
-   * When true the adapter codegen imports it from the domain's fixed `deps`
-   * module and passes it to the worker entry; when false the worker passes the
-   * raw env straight through as `ctx.deps`. Read from the definition, never
-   * probed from the filesystem.
-   */
-  hasDeps: boolean
-}
-
-export interface WatchCtx {
-  /** Absolute path to the domain project root. */
-  projectDir: string
-  /** Absolute path where the CLI writes the diagnostic `spec.json`. */
-  specPath: string
-  /** Flat secret map loaded from the env's `secrets` file — injected locally in dev. */
-  secrets: Record<string, string>
-  /** Domain metadata for codegen. */
-  domain: DomainInfo
-  /** The env key being watched (e.g. 'dev'). */
-  env: string
-  /** Invoked by the adapter on every hot-reload so the CLI can re-log. */
-  onReload(): void
-}
-
-export interface DeployCtx {
-  projectDir: string
-  specPath: string
-  /** Flat secret map loaded from the env's `secrets` file (gitignored). */
-  secrets: Record<string, string>
-  domain: DomainInfo
-  /** The env key being deployed (e.g. 'dev' | 'prod' | 'canary'). */
-  env: string
-  /**
-   * Build the expected install-graph hash for a concrete serving URL from the
-   * current domain definition. Adapters that must verify live drift during
-   * deploy should use this instead of reading `.astrale/spec.json`, which is a
-   * post-deploy diagnostic artifact and may be stale.
-   */
-  schemaHashForUrl?(url: string): Promise<string | undefined>
-}
-
-/** A running local watch — exposes its URL and a stop handle. */
-export interface WatchHandle {
-  /** Local URL the worker is reachable at (e.g. http://localhost:8787). */
-  url: string
-  stop(): Promise<void>
-}
-
-/** A completed deploy — the authoritative public URL. */
-export interface DeployResult {
-  url: string
-  /**
-   * Adapter-specific next-steps block printed INSTEAD of the CLI's default
-   * "install on an instance" footer — managed deploys already installed the
-   * domain, so the default hint is wrong there. Pre-indented plain lines.
-   */
-  nextSteps?: string
-}
-
-export interface DomainAdapter<Params> {
-  /** 'astrale-host' | 'cloudflare' | 'node' | … */
-  name: string
-
-  /** Resolve an env key to this adapter's typed params. Throws on unknown key. */
-  params(env: string): Params
-
-  /** Local + hot-reload (watch) → controllable handle. Orthogonal to env. */
-  watch(params: Params, ctx: WatchCtx): Promise<WatchHandle>
-
-  /**
-   * Optional: re-run codegen for an ALREADY-RUNNING `watch` after
-   * `astrale.config.ts` changed — same shape as `watch` but it must NOT spawn
-   * anything: it only rewrites the generated files, and the running dev server
-   * (which watches them, e.g. `wrangler dev` on its `--config`) picks them up.
-   * Adapters without it fall back to "restart to apply config changes".
-   */
-  regenerate?(params: Params, ctx: WatchCtx): Promise<void>
-
-  /** Build + bundle + ship (the adapter owns ITS build) → authoritative URL. */
-  deploy(params: Params, ctx: DeployCtx): Promise<DeployResult>
-
-  /**
-   * Optional: the path (relative to the project root) of the gitignored secrets
-   * file for these params. The CLI loads it and passes the parsed map as
-   * `ctx.secrets` — keeping secret-file loading generic while the path stays
-   * provider-typed. Return `undefined` for "no secrets file".
-   */
-  secretsFile?(params: Params): string | undefined
-}
-
-/**
- * Spec passed to `defineAdapter` — identical to `DomainAdapter` minus the
- * `params(env)` resolver, which the helper attaches from `envs`. Custom adapter
- * authors use this so they never re-implement env→params resolution.
- */
-export interface AdapterSpec<Params> {
-  name: string
-  /** The provider-typed env map (`{ dev: {...}, prod: {...}, … }`). */
-  envs: Record<string, Params>
-  watch(params: Params, ctx: WatchCtx): Promise<WatchHandle>
-  regenerate?(params: Params, ctx: WatchCtx): Promise<void>
-  deploy(params: Params, ctx: DeployCtx): Promise<DeployResult>
-  secretsFile?(params: Params): string | undefined
-}
-
-/**
- * Build a `DomainAdapter` from a spec + an env map, attaching a `params(env)`
- * resolver that throws a clear error on an unknown key (listing the valid ones).
- */
-export function defineAdapter<Params>(spec: AdapterSpec<Params>): DomainAdapter<Params> {
-  const keys = Object.keys(spec.envs)
-  return {
-    name: spec.name,
-    params(env: string): Params {
-      const params = spec.envs[env]
-      if (params === undefined) {
-        const known = keys.length ? keys.join(', ') : '(none)'
-        throw new Error(
-          `Adapter "${spec.name}": unknown env "${env}". Known envs: ${known}. ` +
-            `Add it to the adapter's env map in astrale.config.ts.`,
-        )
-      }
-      return params
-    },
-    watch: spec.watch,
-    deploy: spec.deploy,
-    ...(spec.regenerate ? { regenerate: spec.regenerate } : {}),
-    ...(spec.secretsFile ? { secretsFile: spec.secretsFile } : {}),
-  }
-}

package/src/config/define-domain.ts

@@ -1,354 +0,0 @@
-/**
- * `defineDomain` — the WORKER-SAFE definition of a domain: what the domain *is*
- * (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
- * imports directly, then attaches the adapter separately with `deploy(domain,
- * adapter)` in `astrale.config.ts` (see `./deploy`).
- *
- * 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 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 { Core, Schema } from '@astrale-os/kernel-dsl'
-
-import { DomainOrigin } from '@astrale-os/kernel-core/domain'
-
-import type { AnyRemoteFunctionDef, ViewDef } from '../define/index.js'
-import type { SchemaMethodsImpl } from '../method/index.js'
-
-// A registry holds views / functions of every deps + param/result shape. Their
-// per-entry typing is enforced at the `defineView` / `defineRemoteFunction` call
-// site; here they're held loosely and, crucially, kept OUT of `TDeps` inference
-// — so `TDeps` is fixed by `methods` alone (the authoritative deps source) and a
-// view authored with the default `unknown` deps can't fight `methods`'s `Env`.
-// oxlint-disable-next-line no-explicit-any
-type AnyViewDef = ViewDef<any>
-// The function bag is the canonical, variance-correct one from `../define` (it
-// must accept functions of any auth policy — see the note there). Aliased to
-// keep the local usages below terse.
-type AnyFunctionDef = AnyRemoteFunctionDef
-
-/**
- * Optional presentation metadata for the domain, served verbatim on the
- * worker's `/meta` endpoint (see `../deploy/meta`) so a host UI can brand a
- * freshly-installed domain. Both the block and every field are optional.
- */
-export interface DomainManifest {
-  /** Domain logo — an inline SVG string or a `data:` URL (no extra validation). */
-  logo?: string
-  /**
-   * Slug of one of THIS domain's own views to open first — the domain's entry
-   * surface. This is the SERVED form: a plain slug, stamped verbatim onto
-   * `/meta`. Authors don't write the slug directly — they pass the view OBJECT
-   * to `defineDomain` (see {@link DomainManifestConfig.entrypoint}), which
-   * resolves it to this slug. Pinned at app install to the `View` node at
-   * `/<origin>/views/<slug>` via the app's `entrypoint` edge.
-   */
-  entrypoint?: string
-  /**
-   * The ROLES this domain declares — named capability identities a workspace
-   * registers when an app for this domain is installed, then assigns to users
-   * (`default: true` roles are auto-assigned to the installing user). The
-   * domain itself grants each role its resource permissions (typically in its
-   * `postInstall`); declaring a role here only names it. Slugs are validated
-   * (lowercase slug charset, unique) at `defineDomain`.
-   */
-  roles?: readonly DomainRoleDecl[]
-}
-
-/** One declared role of the domain (see {@link DomainManifest.roles}). */
-export interface DomainRoleDecl {
-  /** Stable role slug, unique within the domain (e.g. `"editor"`). */
-  slug: string
-  /** Display name; defaults to the slug. */
-  name?: string
-  /** What holding this role means — shown in permission UIs. */
-  description?: string
-  /** Auto-assign this role to the user installing an app for this domain. */
-  default?: boolean
-}
-
-/**
- * The author-facing manifest accepted by {@link defineDomain} — identical to the
- * served {@link DomainManifest} except `entrypoint` is the view OBJECT (a value
- * of the `views` map) rather than its slug. `defineDomain` resolves it to the
- * slug by identity, so a renamed or dropped view is a compile error at the
- * reference site, never a stale string (the same guarantee `postInstall` gives
- * for functions).
- */
-export interface DomainManifestConfig extends Omit<DomainManifest, 'entrypoint'> {
-  /**
-   * The view to open first — the domain's entry surface. Pass the view OBJECT
-   * from this domain's own `views` map (e.g. `entrypoint: views.welcome`).
-   * Resolved to its slug here and served as {@link DomainManifest.entrypoint}.
-   */
-  entrypoint?: AnyViewDef
-}
-
-export interface DefineDomainConfig<S extends Schema, TDeps, TEnv = unknown> {
-  /** The domain schema (from `schema/`). Its `.domain` seeds the default origin. */
-  schema: S
-  /**
-   * The domain's method implementations (from `methods/`), one per schema
-   * method. Typed against `schema` — an unimplemented or misnamed method is a
-   * compile error here.
-   */
-  methods: SchemaMethodsImpl<S, TDeps>
-  /** Declarative genesis nodes and edges materialized with the domain at install time. */
-  core?: Core<S>
-  /**
-   * Map the worker `env` to the handler dependency container (`ctx.deps`).
-   * Run ONCE per cold isolate per serving URL (the built app is cached), NOT
-   * per request — so it's the place to construct ports/clients once instead of
-   * re-deriving them in every handler. Its return type IS `TDeps`: type it the
-   * shape your `methods` read (e.g. `(env) => ({ platform: buildPlatform(env) })`)
-   * and the methods get the rich container, not raw env. The same value reaches
-   * view/function handlers and the `install.authorize` hook.
-   *
-   * Omit for the common case: `env` is passed straight through (`TDeps = TEnv`),
-   * so existing domains are unaffected. The function itself is imported by the
-   * generated worker from a fixed `deps` module, mirroring `methods` — wire it
-   * here so the type check binds `env → TDeps` and the adapter knows to emit it.
-   */
-  deps?: (env: TEnv, url: string) => TDeps
-  /**
-   * The domain's Views (iframe-mountable UIs), keyed by slug. Omit when the
-   * domain has none. Each becomes a `View` node + a worker route.
-   */
-  views?: Record<string, AnyViewDef>
-  /**
-   * The domain's standalone Functions (callables not bound to a class), keyed
-   * by slug. Omit when the domain has none.
-   */
-  functions?: Record<string, AnyFunctionDef>
-  /**
-   * Optional presentation metadata stamped onto `/meta`. When `manifest.entrypoint`
-   * is set it MUST be a view from this domain's own `views` map — passed as the
-   * OBJECT (`entrypoint: views.welcome`), resolved to its slug here. A view that
-   * isn't in `views` is a compile error at the reference site, and the
-   * resolution throws loudly if it's somehow absent — so a typo can never dangle
-   * to a NOT_FOUND view path at install.
-   */
-  manifest?: DomainManifestConfig
-  /**
-   * 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
-   * URL. This is **NOT** the cryptographic identity: the `iss` is the worker's
-   * **serving URL**, pinned by the kernel to the URL it fetched the domain at
-   * during install (and verified against that URL's JWKS). `origin` is a free
-   * addressing label, only required to be unique in the graph.
-   */
-  origin?: string
-  /** Cross-domain deps, by origin. Verified present on the instance at install. */
-  requires?: readonly string[]
-  /**
-   * Where the Domain node physically lives in the graph TREE — an absolute tree
-   * path whose LAST segment is the origin (e.g. `'/domains/crm.acme.dev'`).
-   * Optional; defaults to `/domains/<origin>`. This moves ONLY the physical
-   * `has_parent` position: the domain's `installed_in` edge and EVERY typed
-   * address (`/:<origin>`, `/:<origin>:Class`, …) stay ROOT-mounted, so
-   * addressing is unchanged. A platform domain that must stay top-level sets its
-   * own origin path (e.g. `'/shell.astrale.ai'`).
-   */
-  path?: string
-  /**
-   * 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?: AnyFunctionDef
-}
-
-export interface DomainDefinition {
-  schema: Schema
-  // oxlint-disable-next-line no-explicit-any -- erased at the consumption casts in spec/codegen
-  methods: SchemaMethodsImpl<Schema, any>
-  /** Declarative genesis nodes and edges, preserved through codegen and diagnostic builds. */
-  core?: Core<Schema>
-  /**
-   * env → deps mapper, when the author supplied one. Held loosely (the worker
-   * imports the real function from its own `deps` module); the CLI reads only
-   * its PRESENCE to set `DomainInfo.hasDeps`, the codegen signal.
-   */
-  // oxlint-disable-next-line no-explicit-any -- presence is what the CLI consumes; the typed binding lives at the call site
-  deps?: (env: any, url: string) => any
-  views?: Record<string, ViewDef>
-  functions?: Record<string, AnyFunctionDef>
-  /** Presentation metadata for `/meta`, validated at definition time. */
-  manifest?: DomainManifest
-  origin: string
-  requires: readonly string[]
-  postInstall?: string
-  /** Physical tree path for the Domain node; default `/domains/<origin>`. */
-  path?: string
-}
-
-export function defineDomain<S extends Schema, TDeps, TEnv = unknown>(
-  config: DefineDomainConfig<S, TDeps, TEnv>,
-): DomainDefinition {
-  const rawOrigin = config.origin ?? schemaDomain(config.schema)
-  if (!rawOrigin) {
-    throw new Error(
-      'defineDomain: could not resolve `origin`. Set it explicitly or give the ' +
-        'schema a base domain (`defineSchema("crm.acme.dev", …)`).',
-    )
-  }
-  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(rawOrigin)) {
-    throw new Error(
-      `defineDomain: \`origin\` must be a stable name (e.g. "crm.acme.dev"), not a URL — got "${rawOrigin}". ` +
-        'The deployment URL is an output of deploy, not the identity.',
-    )
-  }
-  // Canonicalize + validate the origin exactly as the kernel does (lowercased,
-  // FQDN-like, matches DOMAIN_ORIGIN_RE). Failing HERE gives a clear authoring-
-  // time error instead of a cryptic failure deep in codegen / install, and makes
-  // `origin` the same lowercased form the kernel stores graph nodes under.
-  let origin: string
-  try {
-    origin = DomainOrigin(rawOrigin)
-  } catch {
-    throw new Error(
-      `defineDomain: invalid \`origin\` "${rawOrigin}". Use a lowercase FQDN-like slug ` +
-        '(letters, digits, ".", "_", "-"), e.g. "crm.acme.dev".',
-    )
-  }
-
-  // `requires` entries are domain origins — validate them with the same rule as
-  // `origin` so a URL or mixed-case entry fails at authoring time, not install.
-  const requires = (config.requires ?? []).map((dep) => {
-    try {
-      return DomainOrigin(dep)
-    } catch {
-      throw new Error(
-        `defineDomain: invalid \`requires\` entry "${dep}". Use the dependency's origin slug ` +
-          '(lowercase FQDN-like, e.g. "example.astrale.ai"), not a URL.',
-      )
-    }
-  })
-
-  // `path`, when set, is the Domain's physical tree path. Validate the
-  // two invariants the serializer/kernel rely on, string-only (no AbsolutePath
-  // import — this module must stay worker-safe): it is absolute with at least one
-  // segment, and its LAST segment equals the origin (the kernel derives origin
-  // from the mount basename in a few places, e.g. has_parent slug + get-access-
-  // token origin recovery). Full structural parse happens at build time.
-  if (config.path !== undefined) {
-    const loc = config.path
-    if (!loc.startsWith('/') || loc === '/') {
-      throw new Error(
-        `defineDomain: \`path\` must be an absolute graph path with at least ` +
-          `one segment (e.g. "/domains/${origin}"), not "${loc}".`,
-      )
-    }
-    if (loc.split('/').pop() !== origin) {
-      throw new Error(
-        `defineDomain: \`path\` last segment must equal the origin "${origin}" ` +
-          `(e.g. "/domains/${origin}" or "/${origin}"), got "${loc}".`,
-      )
-    }
-  }
-
-  // A `manifest.entrypoint` view is resolved to its slug below (in the return),
-  // where a view absent from `views` throws — see `resolveManifest`.
-
-  // Declared roles must carry valid, unique slugs — a role slug becomes a graph
-  // path segment and an identity subject, so the kernel's reserved separators
-  // (`/`, `:`, `@`) can never appear in one. Fail at authoring time.
-  if (config.manifest?.roles !== undefined) {
-    const seen = new Set<string>()
-    for (const role of config.manifest.roles) {
-      if (!/^[a-z0-9][a-z0-9_-]*$/.test(role.slug)) {
-        throw new Error(
-          `defineDomain: invalid \`manifest.roles\` slug "${role.slug}". ` +
-            'Use a lowercase slug (letters, digits, "_", "-"), e.g. "editor".',
-        )
-      }
-      if (seen.has(role.slug)) {
-        throw new Error(`defineDomain: duplicate \`manifest.roles\` slug "${role.slug}".`)
-      }
-      seen.add(role.slug)
-    }
-  }
-
-  return {
-    schema: config.schema,
-    methods: config.methods as DomainDefinition['methods'],
-    ...(config.core ? { core: config.core as DomainDefinition['core'] } : {}),
-    ...(config.deps ? { deps: config.deps as DomainDefinition['deps'] } : {}),
-    ...(config.views ? { views: config.views as Record<string, ViewDef> } : {}),
-    ...(config.functions ? { functions: config.functions } : {}),
-    ...(config.manifest ? { manifest: resolveManifest(config.manifest, config.views) } : {}),
-    origin,
-    requires,
-    ...(config.path ? { path: config.path } : {}),
-    ...(config.postInstall !== undefined
-      ? { postInstall: normalizePostInstall(config.postInstall, origin, config.functions) }
-      : {}),
-  }
-}
-
-/**
- * Lower the author-facing manifest (view OBJECT for `entrypoint`) to the served
- * {@link DomainManifest} (slug for `entrypoint`). The entrypoint view is matched
- * to its `views`-map key by IDENTITY — the same mechanism `normalizePostInstall`
- * uses for functions — so a view absent from `views` (one from another domain,
- * or dropped) throws here instead of dangling to a NOT_FOUND view path at install.
- */
-function resolveManifest(
-  manifest: DomainManifestConfig,
-  views: Record<string, AnyViewDef> | undefined,
-): DomainManifest {
-  const { entrypoint, ...rest } = manifest
-  if (entrypoint === undefined) return rest
-  const slug = views ? Object.entries(views).find(([, def]) => def === entrypoint)?.[0] : undefined
-  if (slug === undefined) {
-    const viewKeys = Object.keys(views ?? {})
-    throw new Error(
-      "defineDomain: `manifest.entrypoint` must be one of this domain's own views " +
-        '(pass the view object, e.g. `entrypoint: views.welcome`). ' +
-        `Available views: ${viewKeys.length > 0 ? viewKeys.map((k) => `"${k}"`).join(', ') : '(none)'}.`,
-    )
-  }
-  return { ...rest, entrypoint: slug }
-}
-
-/**
- * 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: 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` must reference a function from this domain's `functions` map " +
-        '(e.g. `postInstall: functions.seed`).',
-    )
-  }
-  return `/:${origin}:function.${slug}`
-}
-
-function schemaDomain(schema: Schema): string | undefined {
-  const value = (schema as unknown as { domain?: unknown }).domain
-  return typeof value === 'string' && value.length > 0 ? value : undefined
-}

package/src/config/deploy.ts

@@ -1,35 +0,0 @@
-/**
- * `deploy` — bind a worker-safe `DomainDefinition` to a deployment adapter,
- * producing the value `astrale.config.ts` default-exports for the CLI.
- *
- * The split exists to keep the worker bundle clean: `defineDomain` (in the
- * author's `domain.ts`) carries only worker-safe modules and is what the
- * generated worker imports; the adapter (`cloudflare(...)` / `astrale(...)`) is
- * node-only code that the worker must never pull in. `deploy(domain, adapter)`
- * 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 })
- *
- *   import { domain } from './domain'
- *   export default deploy(domain, cloudflare({ dev, prod }))
- *
- * The returned shape is just the definition with `adapter` attached — exactly
- * what the CLI already reads (`def.adapter`, `def.origin`, `def.schema`, …), so
- * the loader is unchanged.
- */
-
-import type { DomainAdapter } from './adapter.js'
-import type { DomainDefinition } from './define-domain.js'
-
-/** A domain definition bound to its deployment adapter — the CLI's input. */
-export interface DeployConfig<Params = unknown> extends DomainDefinition {
-  adapter: DomainAdapter<Params>
-}
-
-export function deploy<Params>(
-  domain: DomainDefinition,
-  adapter: DomainAdapter<Params>,
-): DeployConfig<Params> {
-  return { ...domain, adapter }
-}

package/src/config/index.ts

@@ -1,31 +0,0 @@
-/**
- * `@astrale-os/sdk` config surface — the author-facing declaration of a
- * standalone domain (`astrale.config.ts`) and the deployment-adapter contract.
- *
- *   import { defineDomain, deploy } from '@astrale-os/sdk'
- *   import { cloudflare } from '@astrale-os/adapter-cloudflare'
- *
- * `defineDomain` (in `domain.ts`) declares the WORKER-SAFE domain — what it is +
- * its identity, no adapter. `deploy(domain, adapter)` (in `astrale.config.ts`)
- * binds it to a deployment target; the `astrale-domain` bin (folded into this
- * package — see `../cli`) reads that default export and drives the adapter.
- * Neither builds a server nor boots a kernel — they validate and package the
- * declaration.
- */
-
-export { defineDomain } from './define-domain.js'
-export type { DefineDomainConfig, DomainDefinition, DomainManifest } from './define-domain.js'
-
-export { deploy } from './deploy.js'
-export type { DeployConfig } from './deploy.js'
-
-export { defineAdapter } from './adapter.js'
-export type {
-  AdapterSpec,
-  DeployCtx,
-  DeployResult,
-  DomainAdapter,
-  DomainInfo,
-  WatchCtx,
-  WatchHandle,
-} from './adapter.js'

package/src/define/index.ts

@@ -1,10 +0,0 @@
-export { defineView } from './view.js'
-export type { ViewDef, ViewRenderContext } from './view.js'
-
-export { defineRemoteFunction } from './remote-function.js'
-export type {
-  AnyRemoteFunctionDef,
-  RemoteFunctionAuthorizeContext,
-  RemoteFunctionContext,
-  RemoteFunctionDef,
-} from './remote-function.js'