@astrale-os/adapter-cloudflare 0.1.8 → 0.1.9

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.6 <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,CAmJzF"}

package/dist/astrale.js

@@ -1,222 +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 { defineAdapter, loadDotenvFile } from '@astrale-os/devkit';
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { packAssets } from './assets-pack';
-import { buildClient } from './client';
-import { logTo, prepare } from './cloudflare';
-import { runWranglerBundle, runWranglerDev } from './wrangler-cli';
-const DEFAULT_PORT = 8787;
-const DEFAULT_ADMIN_URL = 'https://admin.eu.astrale.ai/api';
-const DEFAULT_REGION = 'eu';
-const ADMIN_ORIGIN = 'admin.astrale.ai';
-export function astrale(envs) {
-    return defineAdapter({
-        name: 'astrale',
-        envs,
-        // Local dev is unchanged: wrangler dev on localhost. Managed deploys change
-        // WHERE the worker ships, not the inner loop.
-        async watch(params, ctx) {
-            const { configPath } = await prepare({
-                ...(params.vars ? { vars: params.vars } : {}),
-                ...(params.host ? { host: params.host } : {}),
-                port: params.port ?? DEFAULT_PORT,
-            }, ctx, 'dev');
-            const handle = await runWranglerDev({
-                projectDir: ctx.projectDir,
-                configPath,
-                port: params.port ?? DEFAULT_PORT,
-                remote: false,
-                autoPickPort: params.port === undefined,
-                ...(params.host ? { ip: '0.0.0.0' } : {}),
-                onReload: ctx.onReload,
-                onLog: logTo(),
-            });
-            return { url: params.host ?? handle.url, stop: handle.stop };
-        },
-        // Config hot-regen for the local dev loop: same codegen as `watch` (the
-        // running `wrangler dev` reloads its generated config + entry itself) —
-        // the params mapping must stay identical to `watch`'s prepare call.
-        async regenerate(params, ctx) {
-            await prepare({
-                ...(params.vars ? { vars: params.vars } : {}),
-                ...(params.host ? { host: params.host } : {}),
-                port: params.port ?? DEFAULT_PORT,
-            }, ctx, 'dev');
-        },
-        async deploy(params, ctx) {
-            const log = logTo();
-            if (!params.instance) {
-                throw new Error(`astrale adapter: this env has no "instance" — managed deploys need the target ` +
-                    `instance slug (e.g. prod: { instance: '<your-instance-slug>' }).`);
-            }
-            // Build + pack the client SPA: managed services serve it under /ui (the
-            // platform stages the archive and the box downloads it at Service.init).
-            let assetsGz = null;
-            if (ctx.clientDir) {
-                await buildClient(ctx.clientDir, ctx.projectDir, log);
-                assetsGz = packAssets(join(ctx.projectDir, 'dist-client'));
-                if (assetsGz)
-                    log(`packed client SPA (${assetsGz.length} bytes gz) — /ui ships managed`);
-            }
-            // 1. Codegen + bundle: the exact worker module a Cloudflare deploy would
-            //    ship, produced locally with `wrangler deploy --dry-run` (no auth).
-            //    `clientDir` is stripped: managed packages don't ship SPA assets yet,
-            //    and leaving it in would put a dangling `assets.directory` (the
-            //    unbuilt dist-client) into the generated config.
-            const { clientDir: _omitted, ...bundleCtx } = ctx;
-            const { configPath } = await prepare({}, bundleCtx, 'dev');
-            const outDir = join(ctx.projectDir, '.astrale', 'dist-managed');
-            const bundlePath = await runWranglerBundle({
-                projectDir: ctx.projectDir,
-                configPath,
-                outDir,
-                onLog: log,
-            });
-            const bundle = await readFile(bundlePath);
-            // 2. Publish through the platform, authenticated by the author's astrale
-            //    CLI session. The release payload rides STDIN — a bundle is megabytes
-            //    of base64, far past argv limits.
-            const name = params.name ?? packageNameFor(ctx.domain.origin);
-            const adminUrl = params.adminUrl ?? DEFAULT_ADMIN_URL;
-            const version = `0.0.0-managed.${Date.now()}`;
-            log(`registering "${name}" (${ctx.domain.origin}) in the platform catalog…`);
-            await astraleCall(ctx.projectDir, params, adminUrl, {
-                path: `/${ADMIN_ORIGIN}/class.DomainPublished/register`,
-                data: { origin: ctx.domain.origin, name },
-            });
-            log(`publishing ${name}@${version} (${bundle.length} bytes)…`);
-            await astraleCall(ctx.projectDir, params, adminUrl, {
-                path: `/admin/domains/${name}::release`,
-                data: {
-                    version,
-                    bundleBase64: bundle.toString('base64'),
-                    makeCurrent: true,
-                    ...(assetsGz ? { assetsGzBase64: assetsGz.toString('base64') } : {}),
-                },
-                viaStdin: true,
-            });
-            // Author runtime secrets: read the env's dotenv locally, ship the map on
-            // the INSTALL call (never the release — secrets are per instance, never
-            // catalog-resident). Rides stdin so values never appear in argv.
-            let secrets;
-            if (params.secrets) {
-                secrets = loadDotenvFile(join(ctx.projectDir, params.secrets));
-                log(`shipping ${Object.keys(secrets).length} secret(s) from ${params.secrets}…`);
-            }
-            log(`installing on instance "${params.instance}"…`);
-            const installed = (await astraleCall(ctx.projectDir, params, adminUrl, {
-                path: `/admin/domains/${name}::install`,
-                data: {
-                    instanceId: params.instance,
-                    source: { kind: 'package' },
-                    ...(secrets ? { secrets } : {}),
-                },
-                viaStdin: true,
-            }));
-            if (installed.error || installed.state !== 'installed') {
-                throw new Error(`managed install failed: state=${installed.state ?? '?'} error=${installed.error ?? '?'}`);
-            }
-            if (!installed.serviceSlug) {
-                throw new Error('managed install returned no serviceSlug — cannot derive the service URL');
-            }
-            const region = params.region ?? DEFAULT_REGION;
-            const url = `https://${installed.serviceSlug}.svc.${region}.astrale.ai`;
-            return {
-                url,
-                // Managed deploys already installed on the instance — override the
-                // devkit's default "install on an instance" footer with the truth.
-                nextSteps: `  installed on "${params.instance}" — call it:\n` +
-                    `      astrale call "/${ctx.domain.origin}/..." -i ${params.instance}`,
-            };
-        },
-        secretsFile(params) {
-            return params.secrets;
-        },
-    });
-}
-/** Catalog package name from the origin: first DNS label (e.g. `my-notes.example.dev` → `my-notes`). */
-function packageNameFor(origin) {
-    const label = origin.split('.')[0] ?? origin;
-    return label.toLowerCase().replace(/[^a-z0-9-]+/g, '-');
-}
-/**
- * Invoke the user's `astrale` CLI for one platform call and parse its JSON
- * output. The CLI owns identity (IdP session, audience scoping, delegation
- * minting) — reimplementing that here would fork the trust path.
- */
-async function astraleCall(projectDir, params, adminUrl, call) {
-    // Saga-sized timeout: a COLD managed install (fresh service on the host)
-    // runs runtime staging + serve probes and regularly exceeds the CLI's 30s
-    // default — which doesn't just fail the client, it can kill the saga
-    // mid-flight. Same budget as `astrale instance create`.
-    const args = ['call', call.path, '--url', adminUrl, '--json', '--timeout', '240000'];
-    if (params.identity)
-        args.push('--as', params.identity);
-    const payload = JSON.stringify(call.data);
-    if (!call.viaStdin)
-        args.push('--data', payload);
-    const { code, out } = await new Promise((resolve, reject) => {
-        const child = spawn(astraleBin(projectDir), args, {
-            cwd: projectDir,
-            stdio: [call.viaStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
-        });
-        let out = '';
-        child.stdout?.on('data', (b) => (out += b.toString()));
-        child.stderr?.on('data', (b) => (out += b.toString()));
-        child.on('exit', (c) => resolve({ code: c ?? 1, out }));
-        child.on('error', reject);
-        if (call.viaStdin) {
-            child.stdin?.write(payload);
-            child.stdin?.end();
-        }
-    });
-    if (code !== 0) {
-        // Only suggest re-login for AUTH-shaped failures — a timeout or audience
-        // error pointed at "auth login" sends users chasing the wrong fix.
-        const authShaped = /AUTH_ERROR|expired|not signed in|credential/i.test(out);
-        throw new Error(`astrale call ${call.path} failed (exit ${code}): ${out.trim().slice(0, 500)}` +
-            (authShaped ? `\nIs the astrale CLI installed and signed in? (astrale auth login)` : ''));
-    }
-    try {
-        return JSON.parse(out);
-    }
-    catch {
-        throw new Error(`astrale call ${call.path}: could not parse CLI output: ${out.slice(0, 300)}`);
-    }
-}
-/** The user's astrale CLI: ~/.astrale/bin/astrale when present, else PATH. */
-function astraleBin(_projectDir) {
-    const home = process.env.HOME;
-    if (home) {
-        const installed = join(home, '.astrale', 'bin', 'astrale');
-        if (existsSync(installed))
-            return installed;
-    }
-    return 'astrale';
-}
-//# sourceMappingURL=astrale.js.map