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

package/src/linter/rules/oxlint-rule.ts

@@ -1,35 +0,0 @@
-export type AstNode = {
-  type: string
-  parent?: AstNode
-  range?: [number, number]
-  async?: boolean
-  await?: boolean
-  name?: string
-  computed?: boolean
-  object?: AstNode
-  property?: AstNode
-  callee?: AstNode
-  arguments?: AstNode[]
-}
-
-export type OxlintRuleContext = {
-  id: string
-  filename: string
-  cwd: string
-  sourceCode: {
-    text: string
-    getText(node?: AstNode | null): string
-    getLoc(node: AstNode): { start: { line: number; column: number } }
-  }
-  report(diagnostic: { node: AstNode; messageId: string }): void
-}
-
-export type OxlintRule = {
-  meta: {
-    type: 'problem'
-    docs: { description: string; url: string }
-    messages: Record<string, string>
-    schema: readonly []
-  }
-  create(context: OxlintRuleContext): Record<string, ((node: AstNode) => void) | undefined>
-}

package/src/linter/rules/project-rule.ts

@@ -1,37 +0,0 @@
-import type { LintDiagnostic } from '../diagnostic.js'
-import type { DomainProject } from '../project.js'
-import type { SourceFile, SourceToken } from '../source.js'
-
-import { isSuppressed } from '../suppression.js'
-import { ruleCatalog, ruleId, type ImplementedRuleSlug } from './catalog.js'
-
-export type AnalyzerRule = {
-  slug: ImplementedRuleSlug
-  analyze(project: DomainProject): readonly LintDiagnostic[]
-}
-
-export function analyzerDiagnostic(
-  slug: ImplementedRuleSlug,
-  file: SourceFile,
-  token: SourceToken,
-  detail?: string,
-): LintDiagnostic | undefined {
-  const info = ruleCatalog[slug]
-  const id = ruleId(slug)
-  if (isSuppressed(file, token.line, id)) return undefined
-  return {
-    id,
-    severity: 'error',
-    message: detail ? `${info.message} ${detail}` : info.message,
-    help: info.help,
-    url: info.url,
-    owner: info.owner,
-    location: {
-      path: file.relativePath,
-      line: token.line,
-      column: token.column,
-      offset: token.offset,
-      length: token.length,
-    },
-  }
-}

package/src/linter/rules/thin-schema-composition-root.ts

@@ -1,26 +0,0 @@
-import type { LintDiagnostic } from '../diagnostic.js'
-import type { DomainProject } from '../project.js'
-
-import { importedCalls } from '../source.js'
-import { analyzerDiagnostic, type AnalyzerRule } from './project-rule.js'
-
-const schemaModules = new Set(['@astrale-os/kernel-core', '@astrale-os/kernel-dsl'])
-const memberConstructors = new Set([
-  'edgeClass',
-  'edgeInterface',
-  'fn',
-  'func',
-  'nodeClass',
-  'nodeInterface',
-])
-
-export const thinSchemaCompositionRoot: AnalyzerRule = {
-  slug: 'thin-schema-composition-root',
-  analyze(project: DomainProject): readonly LintDiagnostic[] {
-    const root = project.files.find((file) => file.relativePath === 'schema/index.ts')
-    if (!root) return []
-    return importedCalls(root, schemaModules, memberConstructors)
-      .map((token) => analyzerDiagnostic(this.slug, root, token, `Found ${token.value}().`))
-      .filter((diagnostic): diagnostic is LintDiagnostic => diagnostic !== undefined)
-  },
-}

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]
-}