@astrale-os/adapter-cloudflare 0.1.7 → 0.1.9

package/template/core/keys.ts

@@ -0,0 +1,28 @@
+/**
+ * Compiled-schema accessors — the ONE place class paths, method paths, and
+ * qualified prop keys come from. Pure (schema-derived); never hand-write key
+ * strings. `D` (the compiled domain) is the public `schema/compiled` entry,
+ * re-exported here so `core/` and `runtime/` read it — plus the named keys —
+ * from one place.
+ */
+import { K } from '@astrale-os/kernel-core'
+
+import { D } from '../schema/compiled'
+
+export { D, K }
+
+/** Kernel ops/classes the logic addresses. */
+export const NODE_CREATE = K.Node.createNode.path.method.raw
+export const FOLDER_CLASS = K.Folder.path.class.raw
+export const NAME_KEY = K.Named.name.key
+
+/** Domain class paths. */
+export const NOTE_CLASS = D.Note.path.class.raw
+export const REFERENCES_EDGE = D.references.path.class.raw
+
+/** Qualified storage keys for Note node props. */
+export const NOTE_KEYS = {
+  title: D.Note.title.key,
+  body: D.Note.body.key,
+  summary: D.Note.summary.key,
+} as const

package/template/{methods → core}/note.ts

@@ -1,26 +1,27 @@
 /**
- * Note context — method LOGIC, written once, transport-agnostic.
+ * Note context — method LOGIC, written once, transport-agnostic and testable.
  *
  * Each handler touches the kernel ONLY through `kernel.call(...)` (the universal
- * syscalls) plus its `params` and, for instance methods, the source node's
- * `path.raw`. Address callables/edges with layout-independent forms — a
- * `ClassPath` for the edge class, the `<id>::link` instance form, and an
- * `@<id>` id-form target. Reserve an absolute path string for a node *location*.
+ * syscalls) plus its `params`, the resolved `Summarizer` PORT, and — for
+ * instance methods — the source node's `path.raw`. It never names `fetch`, the
+ * worker `env`, or a concrete provider: the port arrives ready-to-use from
+ * `runtime/` (which built it from `deps`). Address callables/edges with
+ * layout-independent forms — a `ClassPath` for the edge class, the `<id>::link`
+ * instance form, and an `@<id>` id-form target.
  */
-import { K } from '@astrale-os/kernel-core'
-
-import { D } from '../schema/compiled'
+import type { Summarizer } from '../integrations/summary/port'
+import {
+  FOLDER_CLASS,
+  NAME_KEY,
+  NODE_CREATE,
+  NOTE_CLASS,
+  NOTE_KEYS,
+  REFERENCES_EDGE,
+} from './keys'
 
 /** The minimal kernel surface the worker runtime exposes to a handler. */
 export type CallableKernel = { call(path: string, params: unknown): Promise<unknown> }
 
-const NODE_CREATE = K.Node.createNode.path.method.raw
-const NAME_KEY = K.Named.name.key
-const NOTE_CLASS = D.Note.path.class.raw
-const REFERENCES_EDGE = D.references.path.class.raw
-const TITLE_KEY = D.Note.title.key
-const BODY_KEY = D.Note.body.key
-
 /** Notes live under a `/notes` folder at the graph root (created by `seed`). */
 const NOTES_PARENT = '/notes'
 
@@ -37,16 +38,26 @@ function slugify(text: string): string {
   return `${stem}-${Date.now().toString(36).slice(-4)}${Math.random().toString(36).slice(2, 6)}`
 }
 
-/** `NoteOps.createNote` (static) — create a Note under `/notes`. */
+/**
+ * `NoteOps.createNote` (static) — create a Note under `/notes`, stamping a
+ * one-line `summary` from the resolved summarizer port (the external-API seam).
+ */
 export async function createNote(
   kernel: CallableKernel,
+  summarizer: Summarizer,
   params: { title: string; body: string },
 ): Promise<{ id: string; path: string }> {
+  const summary = await summarizer.summarize(params.body)
   const path = `${NOTES_PARENT}/${slugify(params.title)}`
   const created = (await kernel.call(NODE_CREATE, {
     class: NOTE_CLASS,
     path,
-    props: { [NAME_KEY]: params.title, [TITLE_KEY]: params.title, [BODY_KEY]: params.body },
+    props: {
+      [NAME_KEY]: params.title,
+      [NOTE_KEYS.title]: params.title,
+      [NOTE_KEYS.body]: params.body,
+      [NOTE_KEYS.summary]: summary,
+    },
   })) as { id: string }
   return { id: created.id, path }
 }
@@ -64,8 +75,6 @@ export async function reference(
   return { linked: params.target }
 }
 
-const FOLDER_CLASS = K.Folder.path.class.raw
-
 const STARTERS: ReadonlyArray<{ slug: string; title: string; body: string }> = [
   {
     slug: 'welcome',
@@ -81,12 +90,15 @@ function isPathConflict(e: unknown): boolean {
 
 /**
  * `Note.seed` (static) — the domain's post-install bootstrap. The kernel calls
- * it ONCE after install, as __SYSTEM__ (see `postInstall` in
- * `astrale.config.ts`), so the domain can lay down its initial state and
- * grants: the `/notes` folder, a couple of starter Notes, and a `references`
- * edge between them. Idempotent: a re-run swallows `PATH_CONFLICT` per node.
+ * it ONCE after install, as __SYSTEM__ (see `postInstall` in `domain.ts`), so
+ * the domain can lay down its initial state: the `/notes` folder, a couple of
+ * starter Notes (each summarized through the port), and a `references` edge
+ * between them. Idempotent: a re-run swallows `PATH_CONFLICT` per node.
  */
-export async function seed(kernel: CallableKernel): Promise<{ seeded: number }> {
+export async function seed(
+  kernel: CallableKernel,
+  summarizer: Summarizer,
+): Promise<{ seeded: number }> {
   // 1. The `/notes` folder at the graph root.
   try {
     await kernel.call(NODE_CREATE, {
@@ -106,7 +118,12 @@ export async function seed(kernel: CallableKernel): Promise<{ seeded: number }>
       const created = (await kernel.call(NODE_CREATE, {
         class: NOTE_CLASS,
         path: `${NOTES_PARENT}/${s.slug}`,
-        props: { [NAME_KEY]: s.title, [TITLE_KEY]: s.title, [BODY_KEY]: s.body },
+        props: {
+          [NAME_KEY]: s.title,
+          [NOTE_KEYS.title]: s.title,
+          [NOTE_KEYS.body]: s.body,
+          [NOTE_KEYS.summary]: await summarizer.summarize(s.body),
+        },
       })) as { id: string }
       ids[s.slug] = created.id
       seeded++

package/template/deps.ts

@@ -0,0 +1,25 @@
+/**
+ * env → handler dependency container — the ONE place the worker env becomes the
+ * typed `ctx.deps` every method reads. `defineDomain({ deps })` mounts it; the
+ * generated worker imports it. Runs ONCE per cold isolate (NOT per request), so
+ * it's where ports/clients are wired once instead of being re-derived in every
+ * handler.
+ *
+ * The summarizer port is resolved ON-REQUEST (lazy `summarizer()` via the
+ * registry), not here — so this stays a cheap synchronous wiring step and a
+ * worker never validates a provider's env until a handler actually uses it.
+ *
+ * Omit the `deps` field in `domain.ts` for the trivial case (handlers then get
+ * raw `Env`). Transform here the moment a handler should depend on a PORT
+ * instead of raw config — that's the whole point of this seam.
+ */
+import { buildSummarizerRegistry, type SummarizerRegistry } from './integrations/summary/registry'
+import type { Env } from './env'
+
+/** Typed dependency container handed to every method as `ctx.deps`. */
+export interface Deps extends SummarizerRegistry {}
+
+/** Map the worker env to the handler deps (the seam `defineDomain({ deps })` mounts). */
+export function deps(env: Env): Deps {
+  return buildSummarizerRegistry(env)
+}

package/template/domain.ts

@@ -0,0 +1,33 @@
+/**
+ * domain.ts — the WORKER-SAFE domain definition: what the domain IS (its
+ * `schema`, `methods`, `deps`, `views`, `functions`, `client`) plus its identity
+ * (`origin` defaults to `schema.domain`; `postInstall`). Everything is wired
+ * EXPLICITLY here — a renamed or mistyped module is a compile error at this
+ * call, never a silently-missing route. The handlers live in `runtime/` (the
+ * composition root), the pure logic in `core/`, the external-API ports in
+ * `integrations/` — but the worker only ever sees this one wired definition.
+ *
+ * The generated worker (`.astrale/worker.gen.ts`) imports THIS and spreads it,
+ * so your folder layout is invisible to it — reorganize freely; only this wiring
+ * has to stay put. The deploy adapter is attached separately in
+ * `astrale.config.ts` via `deploy(domain, …)`, keeping its node-only code
+ * (wrangler, filesystem) out of the worker bundle.
+ */
+import { defineDomain } from '@astrale-os/sdk'
+
+import { deps } from './deps'
+import { functions } from './functions'
+import { methods } from './runtime'
+import { schema } from './schema'
+import { views } from './views'
+
+export const domain = defineDomain({
+  schema,
+  methods,
+  deps,
+  views,
+  functions,
+  client: { dir: 'client' },
+  postInstall: `/:${schema.domain}:class.Note:seed`,
+  requires: [],
+})

package/template/env.ts

@@ -18,5 +18,16 @@ export interface Env {
   SELF?: { fetch(request: Request): Promise<Response> }
   /** Dev-only: forward /ui/* to a running Vite dev server. */
   VIEW_DEV_URL?: string
+
+  // ── Summarizer (the example external-API integration) ─────────────
+  /** Which summarizer adapter to bind: `heuristic` (default, no secret) | `http`. */
+  NOTE_SUMMARIZER?: string
+  /** `http` only — bearer token for the OpenAI-compatible upstream (a secret). */
+  SUMMARIZER_API_KEY?: string
+  /** `http` only — OpenAI-compatible base URL (e.g. https://api.openai.com/v1). */
+  SUMMARIZER_BASE_URL?: string
+  /** `http` only — model id (default gpt-4o-mini). */
+  SUMMARIZER_MODEL?: string
+
   [key: string]: unknown
 }

package/template/integrations/summary/heuristic.ts

@@ -0,0 +1,25 @@
+/**
+ * Heuristic summarizer — the ZERO-CONFIG default adapter. No network, no
+ * secrets: a fresh scaffold summarizes notes out of the box on `pnpm dev`.
+ * It takes the first sentence (clamped), which is good enough to demonstrate
+ * the seam; flip `NOTE_SUMMARIZER=http` (see `registry.ts`) for a real model.
+ */
+import type { Summarizer } from './port'
+
+const DEFAULT_MAX_LENGTH = 140
+
+/** Build the local, dependency-free summarizer. */
+export function createHeuristicSummarizer(opts: { maxLength?: number } = {}): Summarizer {
+  const maxLength = opts.maxLength ?? DEFAULT_MAX_LENGTH
+  return {
+    summarize(body) {
+      const trimmed = body.trim()
+      // First sentence, else the whole (clamped) body.
+      const firstSentence = trimmed.split(/(?<=[.!?])\s/)[0] ?? trimmed
+      const text = firstSentence || trimmed
+      const summary =
+        text.length <= maxLength ? text : `${text.slice(0, maxLength - 1).trimEnd()}…`
+      return Promise.resolve(summary)
+    },
+  }
+}

package/template/integrations/summary/http.ts

@@ -0,0 +1,69 @@
+/**
+ * HTTP summarizer — the REAL external-API adapter: a single OpenAI-compatible
+ * `POST /chat/completions` call. This is the shape your domain's external calls
+ * take — config + secret from `env`, a timeout via `AbortSignal`, upstream
+ * detail preserved in `cause`. Selected by `NOTE_SUMMARIZER=http` (registry.ts);
+ * the default stays the no-network `heuristic` adapter so a fresh scaffold needs
+ * no secret.
+ *
+ * `baseUrl` is anything OpenAI-compatible — `https://api.openai.com/v1`, a
+ * Workers-AI gateway, or your OWN `ai-gateway` domain's `/v1` surface. On a soft
+ * upstream failure it falls back to the heuristic rather than throwing: a flaky
+ * summarizer must never block creating a note (see the port contract).
+ */
+import { createHeuristicSummarizer } from './heuristic'
+import type { Summarizer } from './port'
+
+export interface HttpSummarizerConfig {
+  /** Bearer token for the upstream (a secret — ships via `.env.<env>`). */
+  apiKey: string
+  /** OpenAI-compatible base URL, e.g. `https://api.openai.com/v1`. */
+  baseUrl: string
+  /** Model id, e.g. `gpt-4o-mini`. */
+  model: string
+  /** Upstream request timeout in ms (default 15000). */
+  timeoutMs?: number
+}
+
+const DEFAULT_TIMEOUT_MS = 15_000
+const SYSTEM_PROMPT = 'Summarize the user note in one short sentence. Reply with the summary only.'
+
+/** Build the OpenAI-compatible HTTP summarizer (with a heuristic fallback). */
+export function createHttpSummarizer(config: HttpSummarizerConfig): Summarizer {
+  const fallback = createHeuristicSummarizer()
+  const endpoint = `${config.baseUrl.replace(/\/+$/, '')}/chat/completions`
+  return {
+    async summarize(body) {
+      try {
+        const res = await fetch(endpoint, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json',
+            authorization: `Bearer ${config.apiKey}`,
+          },
+          body: JSON.stringify({
+            model: config.model,
+            messages: [
+              { role: 'system', content: SYSTEM_PROMPT },
+              { role: 'user', content: body },
+            ],
+          }),
+          signal: AbortSignal.timeout(config.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+        })
+        if (!res.ok) {
+          throw new Error(`summarizer upstream returned ${res.status}`, {
+            cause: await res.text().catch(() => undefined),
+          })
+        }
+        const data = (await res.json()) as {
+          choices?: Array<{ message?: { content?: string } }>
+        }
+        const text = data.choices?.[0]?.message?.content?.trim()
+        return text || (await fallback.summarize(body))
+      } catch {
+        // Soft-fail: never block a note create on the summarizer.
+        return fallback.summarize(body)
+      }
+    },
+  }
+}

package/template/integrations/summary/port.ts

@@ -0,0 +1,21 @@
+/**
+ * Summarizer — the PORT between the domain's logic and whatever produces a
+ * note's one-line summary. This is the external-API seam every real domain has
+ * (here: an LLM/summarization API), reduced to the narrowest interface the
+ * logic needs.
+ *
+ * `core/` logic depends on THIS interface only — never on `fetch`, an SDK, or
+ * `env`. Adapters in this folder implement it: `heuristic.ts` (the zero-config
+ * default, no network) and `http.ts` (a real OpenAI-compatible call). The
+ * registry picks one from `env`; the handler logic only ever sees the resolved
+ * port. Swap or add a provider = one adapter + one arm in `registry.ts`.
+ */
+export interface Summarizer {
+  /**
+   * Produce a short, single-line summary of `body`. Called once per note
+   * create/seed, so keep it fast and resilient. Adapters MUST resolve to a
+   * usable string (fall back to a heuristic rather than throwing on a soft
+   * upstream failure) — a flaky summarizer should never block creating a note.
+   */
+  summarize(body: string): Promise<string>
+}

package/template/integrations/summary/registry.ts

@@ -0,0 +1,52 @@
+/**
+ * Summarizer registry — the ONE place the worker env becomes the live
+ * `Summarizer` port. Adding a provider = one more arm in `selectSummarizer`;
+ * handler logic only ever sees the resolved port.
+ *
+ * Selection is ON-REQUEST: the provider is chosen + built lazily on the first
+ * handler that calls `summarizer()`, then cached for the isolate — NOT at
+ * `deps()` construction. A worker left on the default never validates the HTTP
+ * provider's env, and a per-request override could slot in here later.
+ */
+import type { Env } from '../../env'
+import { createHeuristicSummarizer } from './heuristic'
+import { createHttpSummarizer } from './http'
+import type { Summarizer } from './port'
+
+export interface SummarizerRegistry {
+  /** Resolve the configured summarizer port (lazy + cached per isolate). */
+  summarizer(): Summarizer
+}
+
+/** Build the registry from the worker env (the port is built lazily + cached). */
+export function buildSummarizerRegistry(env: Env): SummarizerRegistry {
+  let cached: Summarizer | undefined
+  return {
+    summarizer() {
+      return (cached ??= selectSummarizer(env))
+    },
+  }
+}
+
+const DEFAULT_HTTP_MODEL = 'gpt-4o-mini'
+
+/** Bind the abstract summarizer port to the configured concrete adapter. */
+function selectSummarizer(env: Env): Summarizer {
+  const provider = (env.NOTE_SUMMARIZER || 'heuristic').toLowerCase()
+
+  if (provider === 'http') {
+    if (!env.SUMMARIZER_API_KEY || !env.SUMMARIZER_BASE_URL) {
+      throw new Error(
+        'NOTE_SUMMARIZER=http requires SUMMARIZER_API_KEY and SUMMARIZER_BASE_URL',
+      )
+    }
+    return createHttpSummarizer({
+      apiKey: env.SUMMARIZER_API_KEY,
+      baseUrl: env.SUMMARIZER_BASE_URL,
+      model: env.SUMMARIZER_MODEL || DEFAULT_HTTP_MODEL,
+    })
+  }
+
+  // Default: the zero-config local heuristic (no network, no secret).
+  return createHeuristicSummarizer()
+}

package/template/package.json

@@ -14,11 +14,10 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@astrale-os/adapter-cloudflare": ">=0.1.7 <1.0.0",
-    "@astrale-os/devkit": ">=0.1.5 <1.0.0",
+    "@astrale-os/adapter-cloudflare": ">=0.1.9 <1.0.0",
     "@astrale-os/kernel-core": ">=0.4.3 <1.0.0",
     "@astrale-os/kernel-dsl": ">=0.1.2 <1.0.0",
-    "@astrale-os/sdk": ">=0.1.5 <1.0.0",
+    "@astrale-os/sdk": ">=0.1.7 <1.0.0",
     "@hono/node-server": "^1.19.0",
     "zod": "^4.3.6"
   },

package/template/runtime/index.ts

@@ -0,0 +1,62 @@
+/**
+ * Runtime composition root — the ONLY place request context (kernel/self/params/
+ * auth) and `deps` meet the per-feature logic. Each `execute` resolves the port
+ * it needs (`deps.summarizer()`, on-request) and delegates to the transport-
+ * agnostic functions in `core/`. No business logic lives here.
+ *
+ *   - `createNote` is interface-hosted (static) → `remoteInterfaceMethods`.
+ *   - `reference`  is class-hosted (instance)   → `remoteMethod` + `remoteClassMethods`.
+ *   - `seed`       is class-hosted (static)     — the `postInstall` bootstrap.
+ *
+ * SDK-level `authorize` is an additive throw-to-deny check (returns void). For
+ * finer worker checks see `assertPerm` / `requireOwnership` from `@astrale-os/sdk`.
+ *
+ * Exports the `methods` map the domain definition (`domain.ts`) wires in.
+ */
+import {
+  remoteClassMethods,
+  remoteInterfaceMethods,
+  remoteMethod,
+  type SchemaMethodsImpl,
+} from '@astrale-os/sdk'
+
+import { createNote, reference, seed } from '../core/note'
+import type { Deps } from '../deps'
+import { schema } from '../schema'
+
+const method = remoteMethod<Deps>()
+const interfaceMethods = remoteInterfaceMethods<Deps>()
+const classMethods = remoteClassMethods<Deps>()
+
+const NoteOpsMethods = interfaceMethods(schema, 'NoteOps', {
+  createNote: {
+    authorize: async () => undefined,
+    execute: ({ kernel, params, deps }) => {
+      if (!kernel) throw new Error('createNote requires a kernel credential')
+      return createNote(kernel, deps.summarizer(), params)
+    },
+  },
+})
+
+const referenceMethod = method(schema, 'Note', 'reference', {
+  authorize: async () => undefined,
+  execute: ({ kernel, self, params }) => {
+    if (!kernel) throw new Error('reference requires a kernel credential')
+    return reference(kernel, self.path.raw, params)
+  },
+})
+
+const seedMethod = method(schema, 'Note', 'seed', {
+  authorize: async () => undefined,
+  execute: ({ kernel, deps }) => {
+    if (!kernel) throw new Error('seed requires a kernel credential')
+    return seed(kernel, deps.summarizer())
+  },
+})
+
+const NoteMethods = classMethods(schema, 'Note', { reference: referenceMethod, seed: seedMethod })
+
+export const methods: SchemaMethodsImpl<typeof schema, Deps> = {
+  interface: { NoteOps: NoteOpsMethods },
+  class: { Note: NoteMethods },
+}

package/template/schema/index.ts

@@ -9,6 +9,7 @@
  * them in the `interfaces` / `classes` maps below.
  */
 import { defineSchema, KernelSchema } from '@astrale-os/kernel-core'
+import { compileDomain, type Domain } from '@astrale-os/kernel-core/domain'
 
 import { Note, NoteOps, references } from './note'
 
@@ -17,5 +18,6 @@ export const schema = defineSchema('astrale-domain.example.dev', {
   classes: { Note, references },
   imports: [KernelSchema],
 })
+export const D: Domain<typeof schema> = compileDomain(schema)
 
 export * from './note'

package/template/schema/note.ts

@@ -41,6 +41,9 @@ export const Note = nodeClass({
   props: {
     title: z.string(),
     body: z.string(),
+    // One-line summary, stamped at create/seed time from the `Summarizer` port
+    // (see integrations/summary/) — the external-API seam wired through `deps`.
+    summary: z.string().optional(),
   },
   methods: {
     reference: fn({
@@ -58,7 +61,7 @@ export const Note = nodeClass({
 })
 
 export const references = edgeClass(
-  { as: 'from_note', types: [Note] },
-  { as: 'to_note', types: [Note] },
+  { as: 'from_note', types: [Note], cardinality: '0..*' },
+  { as: 'to_note', types: [Note], cardinality: '0..*' },
   { props: { reason: z.string().optional() } },
 )

package/template/tsconfig.json

@@ -12,6 +12,17 @@
     "esModuleInterop": true,
     "resolveJsonModule": true
   },
-  "include": ["schema", "methods", "views", "functions", "env.ts", "astrale.config.ts"],
-  "exclude": ["node_modules", ".astrale", "dist-client"]
+  "include": [
+    "schema",
+    "core",
+    "integrations",
+    "runtime",
+    "views",
+    "functions",
+    "deps.ts",
+    "env.ts",
+    "domain.ts",
+    "astrale.config.ts"
+  ],
+  "exclude": ["node_modules", ".astrale", ".dist"]
 }

package/template/views/note.ts

@@ -3,7 +3,7 @@
  * an inline-HTML `render` like `welcome`). Because it declares `mount` rather
  * than `render`, the View node's iframe binding points at `<serving url>/ui/note`
  * — the SDK stamps it from the worker's live URL when it builds the install
- * bundle. The Cloudflare adapter serves `/ui/*` from `../dist-client` (built by
+ * bundle. The Cloudflare adapter serves `/ui/*` from `../.dist` (built by
  * `client/` with base `/ui/`) via the Worker's `ASSETS` binding.
  *
  * `viewFor: selfOf(Note)` attaches a `view_for` edge to the `Note` class

package/dist/astrale.d.ts

@@ -1,27 +0,0 @@
-/**
- * `astrale(envs)` — the Astrale-managed deployment adapter.
- *
- * Ships the domain THROUGH the platform instead of to the author's own cloud
- * account: `deploy` builds the same single-module workerd bundle the Cloudflare
- * adapter ships (shared codegen + `wrangler deploy --dry-run`), then publishes
- * it via the admin domain's catalog — `DomainPublished.register` →
- * `::release { bundleBase64 }` (the worker stages the bytes in the platform
- * registry) → `::install { instanceId, source: { kind: 'package' } }`, which
- * deploys it as a host-local Service next to the target instance and installs
- * the domain on it. No Cloudflare account, no wrangler auth — the only
- * credential is the author's Astrale identity, supplied by the `astrale` CLI
- * session this adapter shells out to (the same trust source as
- * `astrale instance install`).
- *
- * `watch` is identical to the Cloudflare adapter's local dev (wrangler dev on
- * localhost) — managed deploys change WHERE the worker runs, not how you
- * iterate locally.
- *
- * Managed deploys ship the client SPA (served under `/ui` by the box) and
- * runtime secrets (dotenv map on the install call, encrypted at rest
- * platform-side; platform-managed env keys always win precedence).
- */
-import type { DomainAdapter } from '@astrale-os/devkit';
-import type { AstraleParams } from './params';
-export declare function astrale(envs: Record<string, AstraleParams>): DomainAdapter<AstraleParams>;
-//# sourceMappingURL=astrale.d.ts.map

package/dist/astrale.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"astrale.d.ts","sourceRoot":"","sources":["../src/astrale.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAQvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAY7C,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,aAAa,CAAC,aAAa,CAAC,CAoIzF"}