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

package/src/linter/source.ts

@@ -1,323 +0,0 @@
-export type SourceToken = {
-  kind: 'identifier' | 'string' | 'punctuation'
-  value: string
-  offset: number
-  length: number
-  line: number
-  column: number
-}
-
-export type SourceImport = {
-  specifier: string
-  token: SourceToken
-  bindings: ReadonlyMap<string, string>
-  namespace?: string
-}
-
-export type SourceFile = {
-  path: string
-  relativePath: string
-  text: string
-  tokens: readonly SourceToken[]
-  imports: readonly SourceImport[]
-}
-
-const identifierStart = /[A-Za-z_$]/
-const identifierPart = /[A-Za-z0-9_$]/
-
-export function scanSource(path: string, relativePath: string, text: string): SourceFile {
-  const tokens = tokenize(text)
-  return { path, relativePath, text, tokens, imports: parseImports(tokens) }
-}
-
-function tokenize(text: string): SourceToken[] {
-  const tokens: SourceToken[] = []
-  let offset = 0
-  let line = 1
-  let column = 1
-
-  const advance = (): string => {
-    const char = text[offset++]!
-    if (char === '\n') {
-      line++
-      column = 1
-    } else {
-      column++
-    }
-    return char
-  }
-
-  while (offset < text.length) {
-    const char = text[offset]!
-    if (/\s/.test(char)) {
-      advance()
-      continue
-    }
-
-    if (char === '/' && text[offset + 1] === '/') {
-      advance()
-      advance()
-      while (offset < text.length && text[offset] !== '\n') advance()
-      continue
-    }
-
-    if (char === '/' && text[offset + 1] === '*') {
-      advance()
-      advance()
-      while (offset < text.length) {
-        if (text[offset] === '*' && text[offset + 1] === '/') {
-          advance()
-          advance()
-          break
-        }
-        advance()
-      }
-      continue
-    }
-
-    if (char === "'" || char === '"') {
-      const quote = char
-      const start = offset
-      const startLine = line
-      const startColumn = column
-      advance()
-      let value = ''
-      while (offset < text.length) {
-        const current = advance()
-        if (current === '\\') {
-          if (offset < text.length) value += decodeEscape(advance())
-          continue
-        }
-        if (current === quote) break
-        value += current
-      }
-      tokens.push({
-        kind: 'string',
-        value,
-        offset: start,
-        length: offset - start,
-        line: startLine,
-        column: startColumn,
-      })
-      continue
-    }
-
-    if (char === '`') {
-      advance()
-      while (offset < text.length) {
-        const current = advance()
-        if (current === '\\') {
-          if (offset < text.length) advance()
-          continue
-        }
-        if (current === '`') break
-      }
-      continue
-    }
-
-    if (identifierStart.test(char)) {
-      const start = offset
-      const startLine = line
-      const startColumn = column
-      let value = advance()
-      while (offset < text.length && identifierPart.test(text[offset]!)) value += advance()
-      tokens.push({
-        kind: 'identifier',
-        value,
-        offset: start,
-        length: offset - start,
-        line: startLine,
-        column: startColumn,
-      })
-      continue
-    }
-
-    tokens.push({
-      kind: 'punctuation',
-      value: char,
-      offset,
-      length: 1,
-      line,
-      column,
-    })
-    advance()
-  }
-
-  return tokens
-}
-
-function decodeEscape(char: string): string {
-  switch (char) {
-    case 'n':
-      return '\n'
-    case 'r':
-      return '\r'
-    case 't':
-      return '\t'
-    default:
-      return char
-  }
-}
-
-function parseImports(tokens: readonly SourceToken[]): SourceImport[] {
-  const imports: SourceImport[] = []
-  for (let index = 0; index < tokens.length; index++) {
-    const token = tokens[index]!
-    if (token.kind !== 'identifier' || (token.value !== 'import' && token.value !== 'export')) {
-      continue
-    }
-
-    if (token.value === 'import' && tokens[index + 1]?.value === '(') {
-      const specifier = tokens[index + 2]
-      if (specifier?.kind === 'string') {
-        imports.push({ specifier: specifier.value, token, bindings: new Map() })
-      }
-      continue
-    }
-
-    const end = statementEnd(tokens, index + 1)
-    let specifierIndex = -1
-    for (let cursor = index + 1; cursor < end; cursor++) {
-      const candidate = tokens[cursor]!
-      if (candidate.kind === 'string') specifierIndex = cursor
-    }
-    if (specifierIndex < 0) continue
-
-    const specifier = tokens[specifierIndex]!
-    const bindings = new Map<string, string>()
-    let namespace: string | undefined
-    if (token.value === 'import') {
-      const fromIndex = findToken(tokens, index + 1, specifierIndex, 'from')
-      const bindingsEnd = fromIndex >= 0 ? fromIndex : specifierIndex
-      const open = findToken(tokens, index + 1, bindingsEnd, '{')
-      if (open >= 0) {
-        const close = findMatching(tokens, open, '{', '}', bindingsEnd)
-        if (close >= 0) parseNamedBindings(tokens, open + 1, close, bindings)
-      }
-      const star = findToken(tokens, index + 1, bindingsEnd, '*')
-      if (star >= 0 && tokens[star + 1]?.value === 'as') namespace = tokens[star + 2]?.value
-    }
-
-    imports.push({
-      specifier: specifier.value,
-      token,
-      bindings,
-      ...(namespace ? { namespace } : {}),
-    })
-    index = Math.max(index, specifierIndex)
-  }
-  return imports
-}
-
-function statementEnd(tokens: readonly SourceToken[], start: number): number {
-  let depth = 0
-  let sawSpecifier = false
-  for (let index = start; index < tokens.length; index++) {
-    const token = tokens[index]!
-    if (token.value === ';' && depth === 0) return index
-    if (token.value === '{' || token.value === '(' || token.value === '[') depth++
-    if (token.value === '}' || token.value === ')' || token.value === ']') depth--
-    if (token.kind === 'string' && depth === 0) sawSpecifier = true
-    const next = tokens[index + 1]
-    if (sawSpecifier && depth === 0 && next && next.line > token.line) return index + 1
-  }
-  return tokens.length
-}
-
-function findToken(
-  tokens: readonly SourceToken[],
-  start: number,
-  end: number,
-  value: string,
-): number {
-  for (let index = start; index < end; index++) {
-    if (tokens[index]?.value === value) return index
-  }
-  return -1
-}
-
-function findMatching(
-  tokens: readonly SourceToken[],
-  start: number,
-  open: string,
-  close: string,
-  end: number,
-): number {
-  let depth = 0
-  for (let index = start; index < end; index++) {
-    if (tokens[index]?.value === open) depth++
-    if (tokens[index]?.value === close && --depth === 0) return index
-  }
-  return -1
-}
-
-function parseNamedBindings(
-  tokens: readonly SourceToken[],
-  start: number,
-  end: number,
-  bindings: Map<string, string>,
-): void {
-  let index = start
-  while (index < end) {
-    if (tokens[index]?.value === ',' || tokens[index]?.value === 'type') {
-      index++
-      continue
-    }
-    const imported = tokens[index]
-    if (!imported || imported.kind !== 'identifier') {
-      index++
-      continue
-    }
-    if (tokens[index + 1]?.value === 'as' && tokens[index + 2]?.kind === 'identifier') {
-      bindings.set(imported.value, tokens[index + 2]!.value)
-      index += 3
-      continue
-    }
-    bindings.set(imported.value, imported.value)
-    index++
-  }
-}
-
-export function importedCalls(
-  file: SourceFile,
-  modules: ReadonlySet<string>,
-  names: ReadonlySet<string>,
-): SourceToken[] {
-  const locals = new Set<string>()
-  const namespaces = new Set<string>()
-  for (const sourceImport of file.imports) {
-    if (!modules.has(sourceImport.specifier)) continue
-    for (const name of names) {
-      const local = sourceImport.bindings.get(name)
-      if (local) locals.add(local)
-    }
-    if (sourceImport.namespace) namespaces.add(sourceImport.namespace)
-  }
-
-  const calls: SourceToken[] = []
-  for (let index = 0; index < file.tokens.length; index++) {
-    const token = file.tokens[index]!
-    if (token.kind !== 'identifier') continue
-    if (locals.has(token.value) && callFollows(file.tokens, index)) {
-      calls.push(token)
-      continue
-    }
-    if (
-      namespaces.has(token.value) &&
-      file.tokens[index + 1]?.value === '.' &&
-      names.has(file.tokens[index + 2]?.value ?? '') &&
-      callFollows(file.tokens, index + 2)
-    ) {
-      calls.push(file.tokens[index + 2]!)
-    }
-  }
-  return calls
-}
-
-function callFollows(tokens: readonly SourceToken[], index: number): boolean {
-  const next = tokens[index + 1]
-  if (next?.value === '(') return true
-  if (next?.value !== '<') return false
-  const close = findMatching(tokens, index + 1, '<', '>', tokens.length)
-  return close >= 0 && tokens[close + 1]?.value === '('
-}

package/src/linter/suppression.ts

@@ -1,11 +0,0 @@
-import type { SourceFile } from './source.js'
-
-const suppression = /^\s*\/\/\s*astrale-disable-next-line\s+(.+?)\s+--\s+\S.*$/
-
-export function isSuppressed(file: SourceFile, line: number, id: string): boolean {
-  if (line <= 1) return false
-  const previous = file.text.split(/\r?\n/)[line - 2]
-  const match = previous ? suppression.exec(previous) : null
-  if (!match) return false
-  return match[1]!.split(/[\s,]+/).includes(id)
-}

package/src/method/class.ts

@@ -1,163 +0,0 @@
-/**
- * Class-level method aggregation.
- *
- * Where `RemoteHandler` describes one method, the types here describe a
- * whole class's worth of methods. `ClassMethodsImpl<S, K, TDeps>` enforces
- * that every implementable method on class `K` is provided. The interface
- * variant handles abstract definitions; the schema variant indexes by class
- * name.
- *
- * `remoteClassMethods` is the identity helper an author calls when supplying
- * a class's full method record — it gives full inference for the class
- * methods at once, complementing `remoteMethod` (one method at a time).
- */
-
-import type {
-  DefForInterface,
-  InterfaceMethodDefs,
-  InterfaceMethodKeys,
-  MethodClassKeys,
-  NonSealedMethodKeys,
-  OwnMethodKeys,
-  ResolveParams,
-  ResolveReturn,
-  SealedKeys,
-} from '@astrale-os/kernel-core/domain'
-import type { ImplementableOwnKeys, Schema } from '@astrale-os/kernel-dsl'
-
-import type { TypedSelf } from '../dispatch/self.js'
-import type { DomainKernel } from './context.js'
-import type { MethodImpl, RemoteHandler } from './single.js'
-
-/** Per-class method implementations for a remote domain. */
-export type ClassMethodsImpl<
-  S extends Schema,
-  K extends MethodClassKeys<S> & string,
-  TDeps = unknown,
-> = {
-  [M in OwnMethodKeys<S, K>]: MethodImpl<S, K, M, TDeps>
-} & {
-  [M in NonSealedMethodKeys<S, K>]: MethodImpl<S, K, M, TDeps>
-} & {
-  [M in SealedKeys<S, K>]?: never
-}
-
-/** Resolve interface method handler directly (InterfaceMethodKeys ≠ MethodKeys). */
-type InterfaceMethodHandler<
-  S extends Schema,
-  K extends string,
-  M extends string,
-  TDeps,
-> = M extends keyof InterfaceMethodDefs<S, K>
-  ? InterfaceMethodDefs<S, K>[M] extends { readonly config: infer MC }
-    ? MC extends { readonly static: true }
-      ? RemoteHandler<
-          ResolveParams<MC>,
-          ResolveReturn<MC>,
-          undefined,
-          TDeps,
-          'required',
-          DomainKernel<S>
-        >
-      : // Non-static interface methods receive the schema-typed `self` keyed by
-        // THIS interface's def — `self.node()` binds to a `BoundNode<D>` with
-        // short-keyed, def-typed `props`, `self.call` is typed, exactly as the
-        // class-method path (`MethodImpl`) does.
-        RemoteHandler<
-          ResolveParams<MC>,
-          ResolveReturn<MC>,
-          TypedSelf<DefForInterface<S, K>, S>,
-          TDeps,
-          'required',
-          DomainKernel<S>
-        >
-    : never
-  : never
-
-/** Per-interface method implementations. */
-export type InterfaceMethodsImpl<
-  S extends Schema,
-  K extends InterfaceMethodKeys<S> & string,
-  TDeps = unknown,
-> = {
-  [M in ImplementableOwnKeys<DefForInterface<S, K>> & string]: InterfaceMethodHandler<
-    S,
-    K,
-    M,
-    TDeps
-  >
-}
-
-/**
- * Namespace-keyed full schema methods map, parameterized by deps.
- * Handlers for classes and interfaces live under distinct `class` / `interface`
- * slots, preventing name collisions between a class and an interface with the
- * same name.
- *
- * `interface` is optional — schemas without non-abstract interface methods
- * (or with no interfaces at all) do not need to provide it.
- */
-export type SchemaMethodsImpl<S extends Schema, TDeps = unknown> = {
-  class: { [K in MethodClassKeys<S> & string]: ClassMethodsImpl<S, K, TDeps> }
-  interface?: { [K in InterfaceMethodKeys<S> & string]: InterfaceMethodsImpl<S, K, TDeps> }
-}
-
-type RejectSealedKeys<S extends Schema, K extends string, I> = keyof I &
-  SealedKeys<S, K> extends never
-  ? I
-  : `Error: sealed methods must not be implemented by class '${K}': ${keyof I & SealedKeys<S, K> & string}`
-
-/** Identity helper for authoring one class's remote methods with full schema typing. */
-export function remoteClassMethods<TDeps>(): <
-  S extends Schema,
-  K extends MethodClassKeys<S> & string,
-  I extends ClassMethodsImpl<S, K, TDeps>,
->(
-  schema: S,
-  className: K,
-  impl: I & RejectSealedKeys<S, K, I>,
-) => I
-export function remoteClassMethods<
-  S extends Schema,
-  K extends MethodClassKeys<S> & string,
-  I extends ClassMethodsImpl<S, K>,
->(schema: S, className: K, impl: I & RejectSealedKeys<S, K, I>): I
-export function remoteClassMethods(...args: unknown[]) {
-  if (args.length === 0) {
-    return (...innerArgs: unknown[]) => innerArgs[2]
-  }
-
-  return args[2]
-}
-
-/**
- * Identity helper for authoring one interface's remote methods with full
- * schema typing — the interface-hosted counterpart of `remoteClassMethods`.
- *
- * Methods declared on an interface (e.g. a static `createNote` on `NoteOps`)
- * live under the `interface:` slot of `SchemaMethodsImpl`. Without this helper
- * an author has to fall back to `any` (there is no other way to name the
- * per-method handler type — `InterfaceMethodHandler` is internal). Returns the
- * per-interface impl object the `interface: { <Name>: … }` slot expects.
- */
-export function remoteInterfaceMethods<TDeps>(): <
-  S extends Schema,
-  K extends InterfaceMethodKeys<S> & string,
-  I extends InterfaceMethodsImpl<S, K, TDeps>,
->(
-  schema: S,
-  interfaceName: K,
-  impl: I,
-) => I
-export function remoteInterfaceMethods<
-  S extends Schema,
-  K extends InterfaceMethodKeys<S> & string,
-  I extends InterfaceMethodsImpl<S, K>,
->(schema: S, interfaceName: K, impl: I): I
-export function remoteInterfaceMethods(...args: unknown[]) {
-  if (args.length === 0) {
-    return (...innerArgs: unknown[]) => innerArgs[2]
-  }
-
-  return args[2]
-}

package/src/method/context.ts

@@ -1,135 +0,0 @@
-/**
- * `RemoteContext` — what every remote method handler receives at runtime.
- *
- * Assembled by the dispatch pipeline before calling `execute`. Carries the
- * validated params, the resolved auth context, the bound node instance (for
- * non-static methods), the typed dependency container, and a
- * `BoundClientSessionView` to call back into the parent kernel, plus explicit
- * `domain`, `caller`, and `fn` namespaces for identity-sensitive work.
- */
-
-import type { AuthPolicy } from '@astrale-os/kernel-api/routed'
-import type { FnMap, SchemaBoundView } from '@astrale-os/kernel-client'
-import type { BoundClientSessionView } from '@astrale-os/kernel-client/session'
-import type { AuthContext } from '@astrale-os/kernel-core'
-import type { Schema } from '@astrale-os/kernel-dsl'
-import type { Defer, Sleep } from '@astrale-os/kernel-server'
-
-import type { FunctionContextApi } from '../auth/function-context.js'
-import type { DomainAuthority } from '../auth/issuer-mint.js'
-import type { Step } from '../step/index.js'
-
-export type { GraphApi } from '@astrale-os/kernel-client/graph'
-
-/**
- * The kernel session a handler holds: a credential-bound view over the parent
- * kernel — the FULL dispatch surface (`call`/`stream`/`binary`/`signal`,
- * `withSchema` typed dispatch, `as` to rebind the acting credential), not just
- * `call`. Name it from `@astrale-os/sdk` instead of reaching into
- * `@astrale-os/kernel-client`. (For the narrow `{ call }` contract — e.g. a
- * tiny test double — see {@link KernelCaller}.)
- *
- */
-export type Kernel = BoundClientSessionView<FnMap>
-
-/** The default handler kernel for one authored domain schema. */
-export type DomainKernel<S extends Schema> = SchemaBoundView<S, FnMap>
-
-/**
- * The `kernel` a handler receives, derived from its declared `auth` policy.
- * The runtime guarantee (see `auth/resolve.ts`) is exact:
- *   - `'required'` (the default) — the dispatcher rejects a credentialless call
- *     before `execute`, so the kernel is ALWAYS present → non-null.
- *   - `'optional'` — a kernel only when a credential was supplied → `… | null`.
- *   - `'public'` — never any inbound credential → `null`. Public handlers that
- *     must touch the graph use `ctx.fn.kernel()` after verifying their upstream.
- *
- * Distributes over a `AuthPolicy` union (e.g. when `auth` is typed but not a
- * literal) to the widened `Kernel | null` — the safe superset, matching the
- * pre-conditional behaviour.
- */
-export type KernelForAuth<
-  TAuth extends AuthPolicy,
-  TKernel extends Kernel = Kernel,
-> = TAuth extends 'public' ? null : TAuth extends 'optional' ? TKernel | null : TKernel
-
-/**
- * The resolved auth context a handler receives, derived from its declared
- * `auth` policy. Mirrors {@link KernelForAuth}: required methods have a
- * verified auth context, optional/public methods encode the nullable cases.
- */
-export type AuthForPolicy<TAuth extends AuthPolicy> = TAuth extends 'public'
-  ? null
-  : TAuth extends 'optional'
-    ? AuthContext | null
-    : AuthContext
-
-export type RemoteEnv = {
-  /** This worker's canonical serving URL. */
-  url: string
-}
-
-export type CallerContext = {
-  /** Issuer of the inbound kernel/peer credential. */
-  iss: string
-  /** Kernel URL associated with this invocation. */
-  url: string
-}
-
-type RemoteBaseContext<
-  TParams,
-  TSelf,
-  TDeps,
-  TKernel = Kernel | null,
-  TAuth extends AuthPolicy = AuthPolicy,
-> = {
-  /** Validated params (Zod-checked against the method's `inputSchema`). */
-  params: TParams
-  /**
-   * Auth context resolved from the inbound delegation credential. Its
-   * nullability follows the method's `auth` policy: non-null for the default
-   * `'required'`, `... | null` for `'optional'`, and `null` for `'public'`.
-   */
-  auth: AuthForPolicy<TAuth>
-  /** Bound node instance — `undefined` for static methods. */
-  self: TSelf
-  /** Typed dependency container injected at server startup. */
-  deps: TDeps
-  /** Local serving metadata. */
-  env: RemoteEnv
-  /**
-   * Credential-bound client to the parent kernel. Domain methods receive a
-   * schema-bound client by default; standalone functions receive the raw
-   * session because they are not owned by a schema class.
-   */
-  kernel: TKernel
-  /** Inbound kernel/peer context. Present only for authenticated invocations. */
-  caller?: CallerContext
-  /** Mint seam for identities THIS DOMAIN issues (`iss` = this worker). */
-  domain: DomainAuthority
-  /** Current function identity tools: grant-bearing credentials and self-bound kernels. */
-  fn: FunctionContextApi
-}
-
-export type RemoteAuthorizeContext<
-  TParams,
-  TSelf,
-  TDeps,
-  TKernel = Kernel | null,
-  TAuth extends AuthPolicy = AuthPolicy,
-> = RemoteBaseContext<TParams, TSelf, TDeps, TKernel, TAuth>
-
-export interface RemoteContext<
-  TParams,
-  TSelf,
-  TDeps,
-  TKernel = Kernel | null,
-  TAuth extends AuthPolicy = AuthPolicy,
-> extends RemoteBaseContext<TParams, TSelf, TDeps, TKernel, TAuth> {
-  /** Durable-shaped step builder. Inline today, replayable by future backends. */
-  step: Step
-  /** Run independent work without making its completion part of this result. */
-  defer: Defer
-  /** Pause execution for a relative duration. Durable hosts may persist the wait. */
-  sleep: Sleep
-}

package/src/method/index.ts

@@ -1,19 +0,0 @@
-export type {
-  AuthForPolicy,
-  DomainKernel,
-  GraphApi,
-  Kernel,
-  KernelForAuth,
-  RemoteAuthorizeContext,
-  RemoteContext,
-} from './context.js'
-export type {
-  RemoteHandler,
-  AnyRemoteHandler,
-  MethodImpl,
-  MethodParams,
-  MethodResult,
-} from './single.js'
-export { remoteMethod } from './single.js'
-export type { ClassMethodsImpl, InterfaceMethodsImpl, SchemaMethodsImpl } from './class.js'
-export { remoteClassMethods, remoteInterfaceMethods } from './class.js'