@astrale-os/sdk 0.4.18 → 0.5.0-beta.1

package/src/domain/define.ts

@@ -1,161 +0,0 @@
-/**
- * Define a remote domain. Views/functions are first-class domain members; their
- * serving URL is stamped later by spec producers and is also the worker issuer.
- */
-
-import type { FunctionBinding } from '@astrale-os/kernel-api/routed'
-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'
-
-import type { DomainManifest } from '../config/define-domain.js'
-import type { AnyRemoteFunctionDef, ViewDef } from '../define/index.js'
-import type { SchemaMethodsImpl } from '../method/class.js'
-import type { AnyRemoteHandler } from '../method/single.js'
-
-import {
-  assertFunctionsMatchSchema,
-  buildFunctionSchemas,
-  DEFAULT_FUNCTIONS_FOLDER,
-} from './extend-functions.js'
-import { buildViewDeclarations, buildViewSchemas, DEFAULT_VIEWS_FOLDER } from './extend-views.js'
-
-export type RemoteDomainConfig<S extends Schema, TDeps> = {
-  schema: S
-  methods: SchemaMethodsImpl<S, TDeps>
-  core?: Core<S>
-
-  views?: Record<string, ViewDef<TDeps>>
-  viewsFolder?: string
-
-  remoteFunctions?: Record<string, AnyRemoteFunctionDef>
-  functionsFolder?: string
-
-  /** Presentation metadata for `/meta` (logo / entry view). Carried verbatim. */
-  manifest?: DomainManifest
-
-  /** Physical tree path for the Domain node (absolute, e.g. `/domains/acme`); default `/domains/<origin>`. */
-  path?: string
-}
-
-/** 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 has structure only; bindings are stamped at materialization. */
-  compiled: CompiledDomain<S>
-  methods: BoundMethod<AnyRemoteHandler>[]
-  // oxlint-disable-next-line no-explicit-any
-  views?: Record<string, ViewDef<any>>
-  remoteFunctions?: Record<string, AnyRemoteFunctionDef>
-  /** Presentation metadata for `/meta` (logo / entry view); `createRemoteServer` stamps it. */
-  manifest?: DomainManifest
-  /** The original config, so `materializeRemoteDomain` re-materializes from source. */
-  config: MaterializeInputs
-  /**
-   * Physical tree path for the Domain node (absolute string, e.g. `/domains/acme`).
-   * Read by `buildInstallGraph` and passed to `serialize` as `treeMount`; unset =>
-   * `/domains/<origin>` (applied in build-spec). Addressing is unaffected.
-   */
-  path?: string
-}
-
-/** The defineRemoteDomain inputs `materializeRemoteDomain` needs to re-materialize. */
-type MaterializeInputs = {
-  userCore?: Core
-  viewsFolder: string
-  functionsFolder: string
-}
-
-export function defineRemoteDomain<TDeps>() {
-  return function <S extends Schema>(config: RemoteDomainConfig<S, TDeps>): RemoteDomain<S> {
-    const viewsFolder = config.viewsFolder ?? DEFAULT_VIEWS_FOLDER
-    const functionsFolder = config.functionsFolder ?? DEFAULT_FUNCTIONS_FOLDER
-
-    // Standalone function handlers must match schema-declared function members.
-    assertFunctionsMatchSchema(config.schema, config.remoteFunctions)
-    // Standalone function handlers must match schema-declared function members.
-    assertFunctionsMatchSchema(config.schema, config.remoteFunctions)
-    const compiled = compileDomain(
-      config.schema,
-      config.core,
-      undefined,
-      config.views ? buildViewDeclarations(config.views) : undefined,
-    )
-    const methods = bindMethods<AnyRemoteHandler>(
-      compiled.$.schema,
-      compiled.$.methods,
-      // oxlint-disable-next-line no-explicit-any
-      config.methods as any,
-    )
-
-    return Object.freeze({
-      compiled,
-      methods,
-      ...(config.views ? { views: config.views } : {}),
-      ...(config.remoteFunctions ? { remoteFunctions: config.remoteFunctions } : {}),
-      ...(config.manifest ? { manifest: config.manifest } : {}),
-      ...(config.path ? { path: config.path } : {}),
-      config: {
-        userCore: config.core,
-        viewsFolder,
-        functionsFolder,
-      },
-    })
-  }
-}
-
-/** Materialize aux member bindings against the real serving URL. Pure and repeatable. */
-export function materializeRemoteDomain<S extends Schema>(
-  domain: RemoteDomain<S>,
-  url: string,
-): { compiled: CompiledDomain<S>; auxiliary: AuxiliaryMetadata | undefined } {
-  const hasAux = Boolean(domain.views || domain.remoteFunctions)
-  if (!hasAux) return { compiled: domain.compiled, auxiliary: undefined }
-
-  const { config } = domain
-  const schema = domain.compiled.$.schema as S
-
-  const compiled = compileDomain(
-    schema,
-    config.userCore as Core<S> | undefined,
-    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: vws.bindings,
-      remoteFunctionBindings: fns.bindings,
-      functionSchemas: fns.schemas,
-      viewSchemas: vws.schemas,
-    },
-  }
-}

package/src/domain/extend-functions.ts

@@ -1,110 +0,0 @@
-/**
- * Materialize the `functions` map (`defineRemoteFunction` entries) into the two
- * halves a standalone-function DOMAIN MEMBER contributes — mirroring how a class
- * method splits across compile + serialize:
- *
- *   - the CONTRACT half — a `func({ input, output })` per slug, declared in the
- *     schema's `functions` group so the compiled domain carries `function.<slug>`
- *     on `refs.functions` (the kernel owns the ref/layout/of_domain mapping).
- *   - `FunctionSchema[]` + per-slug `FunctionBinding` — the IMPL/BINDING half,
- *     fed to `serialize` (url-stamped). The worker route is
- *     `<url>/<functionsFolder>/<slug>`, DECOUPLED from the graph layout — so
- *     `functionsFolder` only names the URL segment, not the node position.
- *
- * A standalone function is NOT a core/instance node: it is attached directly to
- * the Domain via `of_domain` by the kernel-core serializer, so this module never
- * touches `Core`.
- */
-
-import type { FunctionBinding } from '@astrale-os/kernel-api/routed'
-import type { FunctionSchema } from '@astrale-os/kernel-core/domain'
-import type { Schema } from '@astrale-os/kernel-dsl'
-
-import { zodToJsonSchema } from '@astrale-os/kernel-core/domain'
-
-import type { AnyRemoteFunctionDef } from '../define/remote-function.js'
-
-import { functionBindingForManifest } from '../service/functions.js'
-import { resolveBinding } from './binding.js'
-
-/**
- * Default URL segment for a function's worker route (`<url>/functions/<slug>`).
- * Names the HTTP route only — the graph layout (`/<origin>/functions/<slug>`) is
- * a fixed kernel convention, independent of this.
- */
-export const DEFAULT_FUNCTIONS_FOLDER = 'functions'
-const SLUG_RE = /^[a-z][a-z0-9-]*$/
-
-function assertValidSlugs(functions: Record<string, AnyRemoteFunctionDef>): void {
-  for (const slug of Object.keys(functions)) {
-    if (!SLUG_RE.test(slug)) {
-      throw new Error(
-        `defineRemoteDomain: invalid function slug "${slug}" — must match ${SLUG_RE}.`,
-      )
-    }
-  }
-}
-
-/**
- * Contract half — since "functions as first-class defineSchema members", a
- * standalone function's CONTRACT is declared in the SCHEMA (`defineSchema(...,
- * { functions: { seed: func({ input, output }) } })`) and `compileDomain` builds
- * the member refs from it; the SDK map supplies the HANDLER half. This check
- * pins the two halves together at define time: every schema-declared function
- * needs a handler, every handler a declaration — a drifted key fails loudly at
- * authoring, never as a boot-time missing-identity or a dangling graph member.
- */
-export function assertFunctionsMatchSchema(
-  schema: Schema,
-  functions: Record<string, AnyRemoteFunctionDef> | undefined,
-): void {
-  if (functions) assertValidSlugs(functions)
-  const declared = Object.keys(schema.functions ?? {})
-  const handled = Object.keys(functions ?? {})
-  const missingHandler = declared.filter((slug) => !handled.includes(slug))
-  const missingDecl = handled.filter((slug) => !declared.includes(slug))
-  if (missingHandler.length === 0 && missingDecl.length === 0) return
-  const parts: string[] = []
-  if (missingHandler.length > 0) {
-    parts.push(
-      `schema declares function(s) with no handler: ${missingHandler.map((s) => `"${s}"`).join(', ')}`,
-    )
-  }
-  if (missingDecl.length > 0) {
-    parts.push(
-      `handler(s) with no schema declaration: ${missingDecl.map((s) => `"${s}"`).join(', ')} ` +
-        `(declare them in defineSchema's \`functions\` group via \`func({ input, output })\`)`,
-    )
-  }
-  throw new Error(`defineRemoteDomain: functions/schema mismatch — ${parts.join('; ')}.`)
-}
-
-/**
- * Impl/binding half — `FunctionSchema[]` for `serialize` plus the per-slug
- * `FunctionBinding` map the worker mounts routes from. `ref` is the canonical
- * `function.<slug>` member ref (matching `compiled.$.refs.functions`), so the
- * serializer's per-member impl lookup finds it.
- */
-export function buildFunctionSchemas(
-  functions: Record<string, AnyRemoteFunctionDef>,
-  url: string,
-  functionsFolder: string,
-): { schemas: FunctionSchema[]; bindings: Record<string, FunctionBinding> } {
-  const schemas: FunctionSchema[] = []
-  const bindings: Record<string, FunctionBinding> = {}
-  for (const [slug, def] of Object.entries(functions)) {
-    const binding = functionBindingForManifest(
-      resolveBinding(def.binding, url, functionsFolder, slug),
-      def.auth,
-    )
-    bindings[slug] = binding
-    schemas.push({
-      ref: `function.${slug}`,
-      inputSchema: zodToJsonSchema(def.inputSchema),
-      outputSchema: zodToJsonSchema(def.outputSchema),
-      output: 'value',
-      binding,
-    })
-  }
-  return { schemas, bindings }
-}

package/src/domain/extend-views.ts

@@ -1,151 +0,0 @@
-/**
- * Materialize the `views` map (`defineView` entries) into the two halves a view
- * DOMAIN MEMBER contributes — mirroring `extend-functions.ts`:
- *
- *   - `ViewDeclarations` — the CONTRACT half, fed to `compileDomain`'s members
- *     arg. The member ref (`view.<slug>`), the layout (`/<origin>/views/<slug>`),
- *     and the `of_domain` edge slug all derive from the map key.
- *   - `ViewSchema[]` + per-slug `FunctionBinding` — the IMPL half, fed to
- *     `serialize`. A view carries more than a function: a `UI.handshake` mode and
- *     `view_for` target edges (resolved here to graph paths). The worker route is
- *     `<url>/<viewsFolder>/<slug>`, DECOUPLED from the graph layout.
- *
- * A view is NOT a core/instance node: the kernel-core serializer attaches it to
- * the Domain via `of_domain` (slug `view.<slug>`) and emits its `view_for` edges,
- * so this module never touches `Core`.
- */
-
-import type { FunctionBinding } from '@astrale-os/kernel-api/routed'
-import type { ViewDeclarations, ViewSchema } from '@astrale-os/kernel-core/domain'
-import type { Schema } from '@astrale-os/kernel-dsl'
-
-import { DomainPaths } from '@astrale-os/kernel-core/domain'
-import { buildDefOriginMap, scanImportedDefs } from '@astrale-os/kernel-core/domain'
-import {
-  buildDefDescriptorMap,
-  isAbstract,
-  isCorePath,
-  isSelfMarker,
-  type EdgeEndpoint,
-} from '@astrale-os/kernel-dsl'
-
-import type { ViewDef } from '../define/view.js'
-
-import { joinWorkerPath, resolveBinding } from './binding.js'
-
-/**
- * Default URL segment for a view's worker route (`<url>/views/<slug>`). Names the
- * HTTP route only — the graph layout (`/<origin>/views/<slug>`) is a fixed kernel
- * convention, independent of this.
- */
-export const DEFAULT_VIEWS_FOLDER = 'views'
-const SLUG_RE = /^[a-z][a-z0-9-]*$/
-
-// oxlint-disable-next-line no-explicit-any
-type AnyViewDef = ViewDef<any>
-
-function assertValidSlugs(views: Record<string, AnyViewDef>): void {
-  for (const slug of Object.keys(views)) {
-    if (!SLUG_RE.test(slug)) {
-      throw new Error(`defineRemoteDomain: invalid view slug "${slug}" — must match ${SLUG_RE}.`)
-    }
-  }
-}
-
-/** Enforce ViewDef's documented exclusivity: `mount` cannot combine with `render`/`binding`. */
-function assertExclusivity(slug: string, def: AnyViewDef): void {
-  if (def.mount && (def.render || def.binding)) {
-    throw new Error(
-      `defineRemoteDomain: view "${slug}" sets \`mount\` together with ` +
-        `${def.render ? '`render`' : '`binding`'} — they are mutually exclusive.`,
-    )
-  }
-}
-
-/**
- * Contract half — one declaration per `views` map key, for `compileDomain`'s
- * `views` arg. The slug drives ref/path/of_domain; impl/binding/view_for arrive
- * at serialize.
- */
-export function buildViewDeclarations(views: Record<string, AnyViewDef>): ViewDeclarations {
-  assertValidSlugs(views)
-  const out: Record<string, { slug: string }> = {}
-  for (const slug of Object.keys(views)) out[slug] = { slug }
-  return out
-}
-
-/**
- * Impl half — `ViewSchema[]` for `serialize` plus the per-slug `FunctionBinding`
- * map the worker mounts routes from. `viewFor` markers are resolved here to
- * concrete target paths (class meta-nodes) because the kernel-core serializer is
- * pure and does not resolve `defineCore` endpoints.
- */
-export function buildViewSchemas(
-  views: Record<string, AnyViewDef>,
-  url: string,
-  viewsFolder: string,
-  schema: Schema,
-): { schemas: ViewSchema[]; bindings: Record<string, FunctionBinding> } {
-  const schemas: ViewSchema[] = []
-  const bindings: Record<string, FunctionBinding> = {}
-  for (const [slug, def] of Object.entries(views)) {
-    assertExclusivity(slug, def)
-    // `mount` is a worker-relative SPA path → `<url><mount>`; otherwise the
-    // default/overridden `<url>/<viewsFolder>/<slug>`.
-    const binding = def.mount
-      ? { remoteUrl: joinWorkerPath(url, def.mount) }
-      : resolveBinding(def.binding, url, viewsFolder, slug)
-    bindings[slug] = binding
-    // Inline `render` views ship no shell client → default handshake 'none'.
-    const handshake = def.handshake ?? (def.render ? 'none' : undefined)
-    schemas.push({
-      ref: `view.${slug}`,
-      name: slug,
-      binding,
-      ...(handshake ? { handshake } : {}),
-      viewFor: resolveViewForTargets(def.viewFor, schema),
-    })
-  }
-  return { schemas, bindings }
-}
-
-/**
- * Resolve `defineView`'s `viewFor` endpoints to concrete graph path raws.
- * Mirrors kernel-core `compileCore`'s endpoint resolution (the old channel that
- * carried view_for as core edges): `selfOf(Def)` → the def's class/interface
- * meta-node `/<declaringDomain>/{class,interface}.<Name>/self`; a `CorePath`
- * string → its anchored graph path. Empty when the view targets nothing.
- */
-function resolveViewForTargets(
-  viewFor: EdgeEndpoint | readonly EdgeEndpoint[] | undefined,
-  schema: Schema,
-): string[] {
-  if (!viewFor) return []
-  const targets = Array.isArray(viewFor) ? viewFor : [viewFor]
-  if (targets.length === 0) return []
-
-  const descriptorMap = buildDefDescriptorMap(schema)
-  const defOrigins = buildDefOriginMap(schema, scanImportedDefs(schema))
-
-  return targets.map((target) => {
-    if (isSelfMarker(target)) {
-      const def = target.__def
-      const desc = descriptorMap.get(def)
-      if (!desc) {
-        throw new Error(
-          'defineView: `viewFor: selfOf(...)` references a def that is neither in this ' +
-            "schema nor any of its `imports`. Add the def's schema to `imports`.",
-        )
-      }
-      const origin = defOrigins.get(def) ?? schema.domain
-      const dp = DomainPaths.of(origin)
-      return isAbstract(def) ? dp.interface(desc.name).raw : dp.class(desc.name).raw
-    }
-    if (isCorePath(target)) {
-      return DomainPaths.of(schema.domain).corePath(target).raw
-    }
-    throw new Error(
-      'defineView: unsupported `viewFor` endpoint — use `selfOf(Class)` or a CorePath.',
-    )
-  })
-}

package/src/domain/index.ts

@@ -1,4 +0,0 @@
-export { defineRemoteDomain } from './define.js'
-export type { RemoteDomain, RemoteDomainConfig } from './define.js'
-export { buildInstallGraph, buildInstallGraphHash } from './build-spec.js'
-export { toSdkContract } from './contract.js'

package/src/index.ts

@@ -1,165 +0,0 @@
-// ─── Method authoring ────────────────────────────────────────────────────
-export type {
-  MethodParams,
-  MethodResult,
-  AuthForPolicy,
-  DomainKernel,
-  GraphApi,
-  Kernel,
-  KernelForAuth,
-  RemoteAuthorizeContext,
-  RemoteContext,
-  RemoteHandler,
-  MethodImpl,
-  ClassMethodsImpl,
-  InterfaceMethodsImpl,
-  SchemaMethodsImpl,
-} from './method/index.js'
-export { remoteMethod, remoteClassMethods, remoteInterfaceMethods } from './method/index.js'
-
-// ─── Domain configuration (astrale.config.ts) ────────────────────────────
-// The author-facing way to declare a standalone domain + how it deploys. The
-// runtime-domain COMPILER (`defineRemoteDomain`) is internal machinery — reach
-// it via the `@astrale-os/sdk/domain` subpath when hand-rolling a worker, or
-// (preferred) use `domainWorkerEntry` from `@astrale-os/sdk/server`.
-export { defineDomain, deploy, defineAdapter } from './config/index.js'
-export type {
-  DefineDomainConfig,
-  DomainDefinition,
-  DomainManifest,
-  DeployConfig,
-  AdapterSpec,
-  DeployCtx,
-  DeployResult,
-  DomainAdapter,
-  DomainInfo,
-  WatchCtx,
-  WatchHandle,
-} from './config/index.js'
-
-// ─── Install graph (advanced) ────────────────────────────────────────────
-export { buildInstallGraph, buildInstallGraphHash } from './domain/index.js'
-
-// ─── Graph patching (advanced) ────────────────────────────────────────
-// Author-facing patch types, re-exported from kernel-core (the single source).
-// Build a `Patch` and feed it straight to `ctx.kernel.mutate(patch)` (it implements
-// `PatchData`); the graph sugar itself lives in `@astrale-os/kernel-client/graph`,
-// flattened onto `ctx.kernel`, and `function.mutate` validates every patch kernel-side
-// against kernel-core's `patchDataSchema` — no client-side re-validation needed.
-export { AbsolutePath, Patch, Path } from '@astrale-os/kernel-core'
-export { ClassPath } from '@astrale-os/kernel-core/domain'
-export type {
-  EdgeCreate,
-  EdgeDelete,
-  EdgeMatcher,
-  EdgeUpdate,
-  NodeCreate,
-  NodeDelete,
-  NodeUpdate,
-  PatchData,
-} from '@astrale-os/kernel-core'
-
-// ─── Declarative resource helpers ────────────────────────────────────────
-// Author Views (iframe-mountable) and RemoteFunctions (standalone callables)
-// at the domain definition site. Each `defineView` / `defineRemoteFunction`
-// entry is auto-materialized by `defineRemoteDomain` into a graph node (a
-// `View`, or the canonical kernel `Function` for standalone callables) under
-// the reserved views / functions folder, keyed by its map slug; the same
-// entry's `render` / `execute` (+ auth hooks) is mounted as a worker route by
-// `createRemoteServer`.
-export { defineView, defineRemoteFunction } from './define/index.js'
-export type {
-  ViewDef,
-  ViewRenderContext,
-  RemoteFunctionAuthorizeContext,
-  RemoteFunctionDef,
-  RemoteFunctionContext,
-} from './define/index.js'
-
-// ─── Durable-shaped steps ────────────────────────────────────────────────
-export type { Step } from './step/index.js'
-
-// ─── Invocation capabilities ─────────────────────────────────────────────
-export type { Defer, DeferredTask, Sleep } from '@astrale-os/kernel-server'
-
-// ─── Server ──────────────────────────────────────────────────────────────
-// `createRemoteServer` dynamically imports `@hono/node-server` via `./server/start`.
-// Exporting the server surface from the barrel poisons browser bundlers
-// (Vite/esbuild) that traverse every re-export and try to bundle the dynamic
-// chunk — which fails on Node built-ins. Consumers that need the server
-// runtime import from '@astrale-os/sdk/server' directly.
-
-// ─── Deploy ──────────────────────────────────────────────────────────────
-// `deployCheck` uses Node-only modules (`node:path`, `node:child_process`) at
-// module load time. Exporting it from the barrel poisons browser bundlers
-// (Vite/esbuild) that transitively load every re-export. Consumers that need it
-// import from './deploy' directly.
-export { MetaSchema } from './deploy/meta.js'
-export type { Meta } from './deploy/meta.js'
-
-// ─── Service-hosted Functions ───────────────────────────────────────────
-export {
-  SERVICE_FUNCTIONS_PATH,
-  ServiceFunctionDiscoveryRequestSchema,
-  ServiceFunctionDiscoveryResponseSchema,
-  ServiceFunctionManifestEntrySchema,
-  ServiceFunctionManifestSchema,
-  hashServiceFunctionManifest,
-  signServiceFunctionManifest,
-  verifyServiceFunctionManifest,
-} from './service/index.js'
-export type {
-  ServiceFunctionDiscoveryRequest,
-  ServiceFunctionDiscoveryResponse,
-  ServiceFunctionManifest,
-  ServiceFunctionManifestEntry,
-} from './service/index.js'
-
-// ─── Route binding (re-exported from kernel-api for consumer convenience) ─
-export type {
-  AuthPolicy,
-  RouteBinding,
-  FunctionBinding,
-  CredentialSource,
-  SingleCredentialSource,
-  HttpMethod,
-  RouteBody,
-  OutputMode,
-} from '@astrale-os/kernel-api/routed'
-
-// ─── Auth ────────────────────────────────────────────────────────────────
-export type { RemoteIdentityConfig, AuthenticateResult } from './auth/index.js'
-export type {
-  DomainAuthority,
-  FunctionContextApi,
-  FunctionCredentialOptions,
-  FunctionKernelOptions,
-  MintIssuedParams,
-} from './auth/index.js'
-export {
-  authenticateRequest,
-  buildComposedGrant,
-  makeFunctionContext,
-  signCredential,
-} from './auth/index.js'
-export { AuthMissingError, AuthInvalidError } from './auth/index.js'
-export { assertPerm, requireOwnership, READ, EDIT, USE, SHARE, ALL } from './auth/index.js'
-export type {
-  AuthContext,
-  Attestation,
-  Authenticated,
-  Delegation,
-  IdentityId,
-  IssuerId,
-} from '@astrale-os/kernel-core'
-export { selfGrant } from '@astrale-os/kernel-core'
-
-// ─── Dispatch (escape hatch for custom integrations) ─────────────────────
-export { SdkDispatcher, type SdkDispatcherConfig } from './dispatch/index.js'
-export {
-  AuthorizationDeniedError,
-  MethodNotFoundError,
-  SdkValidationError,
-  SdkResultValidationError,
-} from './dispatch/index.js'
-export type { SelfResult, TypedSelf } from './dispatch/index.js'

package/src/linter/analyze.ts

@@ -1,17 +0,0 @@
-import type { LintDiagnostic } from './diagnostic.js'
-import type { DomainProject } from './project.js'
-import type { AnalyzerRule } from './rules/project-rule.js'
-
-import { coreIsPure } from './rules/core-is-pure.js'
-import { oneRemoteDefinitionPerFile } from './rules/one-remote-definition-per-file.js'
-import { thinSchemaCompositionRoot } from './rules/thin-schema-composition-root.js'
-
-export const analyzerRules: readonly AnalyzerRule[] = [
-  thinSchemaCompositionRoot,
-  oneRemoteDefinitionPerFile,
-  coreIsPure,
-]
-
-export function analyzeProject(project: DomainProject): LintDiagnostic[] {
-  return analyzerRules.flatMap((rule) => rule.analyze(project))
-}

package/src/linter/diagnostic.ts

@@ -1,68 +0,0 @@
-import type { RuleOwner } from './rules/catalog.js'
-
-export type DiagnosticSeverity = 'error' | 'warning'
-
-export type DiagnosticLocation = {
-  path: string
-  line: number
-  column: number
-  offset?: number
-  length?: number
-}
-
-export type LintDiagnostic = {
-  id: string
-  severity: DiagnosticSeverity
-  message: string
-  help?: string
-  url?: string
-  owner: RuleOwner | 'generic'
-  location?: DiagnosticLocation
-}
-
-export type LintResult = {
-  root: string
-  diagnostics: LintDiagnostic[]
-  files: number
-  durationMs: number
-  exitCode: 0 | 1
-}
-
-export class LinterToolError extends Error {
-  readonly exitCode = 2
-
-  constructor(message: string, options?: ErrorOptions) {
-    super(message, options)
-    this.name = 'LinterToolError'
-  }
-}
-
-export function compareDiagnostics(a: LintDiagnostic, b: LintDiagnostic): number {
-  return (
-    (a.location?.path ?? '').localeCompare(b.location?.path ?? '') ||
-    (a.location?.line ?? 0) - (b.location?.line ?? 0) ||
-    (a.location?.column ?? 0) - (b.location?.column ?? 0) ||
-    a.id.localeCompare(b.id) ||
-    a.message.localeCompare(b.message)
-  )
-}
-
-export function dedupeDiagnostics(diagnostics: readonly LintDiagnostic[]): LintDiagnostic[] {
-  const seen = new Set<string>()
-  const result: LintDiagnostic[] = []
-  for (const diagnostic of diagnostics) {
-    const location = diagnostic.location
-    const key = [
-      diagnostic.id,
-      location?.path ?? '',
-      location?.line ?? 0,
-      location?.column ?? 0,
-      location?.length ?? 0,
-      diagnostic.message,
-    ].join(':')
-    if (seen.has(key)) continue
-    seen.add(key)
-    result.push(diagnostic)
-  }
-  return result.sort(compareDiagnostics)
-}