@astrale-os/adapter-cloudflare 0.1.1 → 0.1.3

package/dist/codegen/merge.js

@@ -0,0 +1,91 @@
+/**
+ * Deep-merge for the generated wrangler config. `base` is what the adapter
+ * generates; `overlay` is the dev's `params.wrangler` escape hatch. The merge
+ * is additive so a dev can declare extra bindings without losing the adapter's
+ * invariants:
+ *   - plain objects      → recurse
+ *   - arrays             → concat, de-duplicating BOTH primitive members and
+ *                          object bindings by an identity key (`binding` /
+ *                          `pattern` / `queue` / `name`, else structural value),
+ *                          with the overlay entry overriding a base entry of the
+ *                          same identity. So a dev overlay that re-declares the
+ *                          adapter's `SELF` service (or any binding) replaces it
+ *                          instead of emitting a duplicate wrangler rejects.
+ *   - scalars / new keys → overlay wins
+ *
+ * Protecting the load-bearing keys (`main`, `assets`, …) is policy enforced by
+ * the caller (`generateWranglerConfig`), not here — this stays a generic merge.
+ */
+export function deepMergeConfig(base, overlay) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(overlay)) {
+        const prev = out[key];
+        if (isPlainObject(prev) && isPlainObject(value)) {
+            out[key] = deepMergeConfig(prev, value);
+        }
+        else if (Array.isArray(prev) && Array.isArray(value)) {
+            out[key] = mergeArrays(prev, value);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/**
+ * Concat two arrays, de-duplicating by identity. Primitives dedup by value;
+ * objects dedup by an identity key (`binding`/`pattern`/`queue`/`name`, else
+ * their structural JSON) with the later (overlay) entry overriding an earlier
+ * (base) one at the base entry's position. This stops a re-declared object
+ * binding (e.g. a second `SELF` service) from producing a duplicate that
+ * wrangler rejects, while still appending genuinely distinct bindings.
+ */
+function mergeArrays(a, b) {
+    const out = [];
+    const seenPrimitives = new Set();
+    const indexByKey = new Map();
+    for (const item of [...a, ...b]) {
+        if (isPrimitive(item)) {
+            if (seenPrimitives.has(item))
+                continue;
+            seenPrimitives.add(item);
+            out.push(item);
+            continue;
+        }
+        const key = identityKey(item);
+        const existing = indexByKey.get(key);
+        if (existing !== undefined) {
+            out[existing] = item; // overlay (later) overrides the base entry in place
+            continue;
+        }
+        indexByKey.set(key, out.length);
+        out.push(item);
+    }
+    return out;
+}
+/**
+ * Stable identity for an array's object member: the first recognized wrangler
+ * binding field (`binding` for services/KV/R2/D1/queue producers, `pattern` for
+ * routes, `queue` for consumers, `name` as a generic fallback), else the member's
+ * full structural JSON so identical objects dedup but distinct ones all survive.
+ */
+function identityKey(item) {
+    const rec = item;
+    for (const field of ['binding', 'pattern', 'queue', 'name']) {
+        if (typeof rec[field] === 'string')
+            return `${field}:${rec[field]}`;
+    }
+    try {
+        return `json:${JSON.stringify(item)}`;
+    }
+    catch {
+        return `ref:${String(item)}`;
+    }
+}
+function isPlainObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function isPrimitive(v) {
+    return v === null || (typeof v !== 'object' && typeof v !== 'function');
+}
+//# sourceMappingURL=merge.js.map

package/dist/codegen/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../src/codegen/merge.ts"],"names":[],"mappings":"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"}

package/dist/codegen/worker.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Codegen for the Cloudflare Worker entry (`.astrale/worker.gen.ts`).
+ *
+ * The dev writes only schema/methods/views/functions; this generates the
+ * `export default { fetch }` plumbing the adapter owns. Key properties:
+ *
+ *  • Per-request `url` = the live serving origin (`scheme://host`). It is passed
+ *    only to `createRemoteServer({ url })`; the SDK stamps every
+ *    `binding.remoteUrl` from that single value at spec-build time — so deployed
+ *    Function nodes point back at THIS worker with zero hardcoded URLs.
+ *  • Self-issued JWKS: a Worker can't fetch its own hostname; the verifier
+ *    resolves a credential whose `iss` is this worker from the in-memory key,
+ *    so no self-fetch is attempted (the worker's JWKS is served as a normal
+ *    route by createRemoteServer).
+ *  • Self-binding (autobinding): when a handler calls back into its OWN domain
+ *    (`ctx.callRemote`), the redirect resolves to this worker's own host — a
+ *    forbidden same-host subrequest. We route those through the `SELF` service
+ *    binding instead.
+ *  • SPA: `/ui/*` is served from the `ASSETS` binding (or proxied to Vite in
+ *    dev via `VIEW_DEV_URL`).
+ */
+export interface WorkerCodegenOptions {
+    origin: string;
+    postInstall?: string;
+    requires: readonly string[];
+    hasViews: boolean;
+    hasFunctions: boolean;
+    hasClient: boolean;
+}
+export declare function generateWorkerEntry(opts: WorkerCodegenOptions): string;
+//# sourceMappingURL=worker.d.ts.map

package/dist/codegen/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/codegen/worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;IAC3B,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;CACnB;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,oBAAoB,GAAG,MAAM,CAyEtE"}

package/dist/codegen/worker.js

@@ -0,0 +1,93 @@
+/**
+ * Codegen for the Cloudflare Worker entry (`.astrale/worker.gen.ts`).
+ *
+ * The dev writes only schema/methods/views/functions; this generates the
+ * `export default { fetch }` plumbing the adapter owns. Key properties:
+ *
+ *  • Per-request `url` = the live serving origin (`scheme://host`). It is passed
+ *    only to `createRemoteServer({ url })`; the SDK stamps every
+ *    `binding.remoteUrl` from that single value at spec-build time — so deployed
+ *    Function nodes point back at THIS worker with zero hardcoded URLs.
+ *  • Self-issued JWKS: a Worker can't fetch its own hostname; the verifier
+ *    resolves a credential whose `iss` is this worker from the in-memory key,
+ *    so no self-fetch is attempted (the worker's JWKS is served as a normal
+ *    route by createRemoteServer).
+ *  • Self-binding (autobinding): when a handler calls back into its OWN domain
+ *    (`ctx.callRemote`), the redirect resolves to this worker's own host — a
+ *    forbidden same-host subrequest. We route those through the `SELF` service
+ *    binding instead.
+ *  • SPA: `/ui/*` is served from the `ASSETS` binding (or proxied to Vite in
+ *    dev via `VIEW_DEV_URL`).
+ */
+export function generateWorkerEntry(opts) {
+    const optionalImports = [
+        opts.hasViews ? `import { views } from '../views'` : `const views = undefined`,
+        opts.hasFunctions ? `import { functions } from '../functions'` : `const functions = undefined`,
+    ].join('\n');
+    const postInstallLine = opts.postInstall !== undefined
+        ? `const POST_INSTALL = ${JSON.stringify(opts.postInstall)}`
+        : `const POST_INSTALL = undefined`;
+    return `// AUTO-GENERATED by @astrale-os/adapter-cloudflare — do not edit.
+// Regenerated on every \`astrale-domain dev|deploy\`. Edit schema/methods/views
+// instead. (origin: ${opts.origin})
+import { defineRemoteDomain } from '@astrale-os/sdk'
+import { createWorkerEntry } from '@astrale-os/sdk/server'
+
+import { schema } from '../schema'
+import { methods } from '../methods'
+${optionalImports}
+import { PRIVATE_JWK } from './identity'
+
+const REQUIRES = ${JSON.stringify(opts.requires)}
+${postInstallLine}
+
+interface Env {
+  WORKER_URL?: string
+  ASSETS?: { fetch(request: Request): Promise<Response> }
+  SELF?: { fetch(request: Request): Promise<Response> }
+  VIEW_DEV_URL?: string
+  [key: string]: unknown
+}
+
+// All the shared worker plumbing — JWKS self-fetch shim, SELF-binding routing,
+// per-URL app cache, canonical iss resolution — lives in createWorkerEntry.
+export default createWorkerEntry<Env>({
+  // The worker's serving URL = its identity (iss). Prefer the adapter-injected
+  // WORKER_URL (pins one canonical host for routed deploys, so iss stays stable
+  // even when also reachable via *.workers.dev); fall back to the per-request
+  // host for dev / workers.dev-only (single-host → it IS the canonical URL).
+  resolveUrl: (env, requestOrigin) => env.WORKER_URL ?? requestOrigin,
+  selfBinding: (env) => env.SELF,
+  build: (url, env) => {
+    const domain = defineRemoteDomain()({
+      schema,
+      methods,
+      ...(views ? { views } : {}),
+      ...(functions ? { remoteFunctions: functions } : {}),
+    })
+    return {
+      domain,
+      deps: env,
+      url,
+      privateKey: PRIVATE_JWK,
+      ...(POST_INSTALL ? { postInstall: POST_INSTALL } : {}),
+      ...(REQUIRES.length ? { requires: REQUIRES } : {}),
+    }
+  },
+  // SPA under /ui/* (views with a client renderer).
+  before: (env, url, request) => {
+    if (env.ASSETS && (url.pathname === '/ui' || url.pathname.startsWith('/ui/'))) {
+      if (env.VIEW_DEV_URL) {
+        const devBase = env.VIEW_DEV_URL.replace(/\\/$/, '')
+        return fetch(new Request(\`\${devBase}\${url.pathname}\${url.search}\`, request))
+      }
+      const stripped = url.pathname.replace(/^\\/ui\\/?/, '/')
+      const rewritten = new URL(stripped + url.search, url.origin)
+      return env.ASSETS.fetch(new Request(rewritten, request))
+    }
+    return undefined
+  },
+})
+`;
+}
+//# sourceMappingURL=worker.js.map

package/dist/codegen/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../src/codegen/worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAWH,MAAM,UAAU,mBAAmB,CAAC,IAA0B;IAC5D,MAAM,eAAe,GAAG;QACtB,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,kCAAkC,CAAC,CAAC,CAAC,yBAAyB;QAC9E,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,0CAA0C,CAAC,CAAC,CAAC,6BAA6B;KAC/F,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAEZ,MAAM,eAAe,GACnB,IAAI,CAAC,WAAW,KAAK,SAAS;QAC5B,CAAC,CAAC,wBAAwB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;QAC5D,CAAC,CAAC,gCAAgC,CAAA;IAEtC,OAAO;;uBAEc,IAAI,CAAC,MAAM;;;;;;EAMhC,eAAe;;;mBAGE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC;EAC9C,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDhB,CAAA;AACD,CAAC"}

package/dist/codegen/wrangler.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Codegen for the Worker config (`.astrale/wrangler.gen.jsonc`). This is the
+ * `wrangler.jsonc` that used to be hand-copied into every domain — now an
+ * internal adapter detail the dev never sees.
+ *
+ * `main` is `./worker.gen.ts` (same dir). `assets.directory` is `../dist-client`
+ * (the project's Vite build). A `SELF` service binding enables autobinding
+ * (a handler calling back into its own domain). Custom-domain deploys attach a
+ * `custom_domain` route; otherwise the Worker ships to `*.workers.dev`.
+ *
+ * A dev's `params.wrangler` escape hatch is deep-merged on top of this base
+ * (extra bindings: KV, R2, D1, queues, …) — see `mergeUserConfig`.
+ */
+export interface WranglerCodegenOptions {
+    workerName: string;
+    /** Full custom hostname for a routed deploy (e.g. 'crm.acme.dev'). */
+    route?: string;
+    /** Whether the project has a built client SPA to serve under /ui/*. */
+    hasClient: boolean;
+    /** Plain (non-secret) vars to bake in. */
+    vars?: Record<string, string>;
+    /** Add the SELF service binding (autobinding). */
+    selfBinding: boolean;
+    /**
+     * Raw wrangler config to deep-merge over the generated base — the escape
+     * hatch for extra bindings (KV, R2, D1, queues, service bindings, extra
+     * `compatibility_flags`, cron `triggers`, …). Arrays concat; new keys are
+     * added as-is. The adapter-owned keys `name`, `main`, `assets`, `routes` are
+     * rejected (throws) — use `workerName` / `route` instead.
+     */
+    wrangler?: Record<string, unknown>;
+}
+export declare function generateWranglerConfig(opts: WranglerCodegenOptions): string;
+//# sourceMappingURL=wrangler.d.ts.map

package/dist/codegen/wrangler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrangler.d.ts","sourceRoot":"","sources":["../../src/codegen/wrangler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,SAAS,EAAE,OAAO,CAAA;IAClB,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,kDAAkD;IAClD,WAAW,EAAE,OAAO,CAAA;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAID,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,sBAAsB,GAAG,MAAM,CAiC3E"}

package/dist/codegen/wrangler.js

@@ -0,0 +1,61 @@
+/**
+ * Codegen for the Worker config (`.astrale/wrangler.gen.jsonc`). This is the
+ * `wrangler.jsonc` that used to be hand-copied into every domain — now an
+ * internal adapter detail the dev never sees.
+ *
+ * `main` is `./worker.gen.ts` (same dir). `assets.directory` is `../dist-client`
+ * (the project's Vite build). A `SELF` service binding enables autobinding
+ * (a handler calling back into its own domain). Custom-domain deploys attach a
+ * `custom_domain` route; otherwise the Worker ships to `*.workers.dev`.
+ *
+ * A dev's `params.wrangler` escape hatch is deep-merged on top of this base
+ * (extra bindings: KV, R2, D1, queues, …) — see `mergeUserConfig`.
+ */
+import { deepMergeConfig } from './merge';
+const COMPATIBILITY_DATE = '2025-03-01';
+export function generateWranglerConfig(opts) {
+    const config = {
+        name: opts.workerName,
+        main: './worker.gen.ts',
+        compatibility_date: COMPATIBILITY_DATE,
+        compatibility_flags: ['nodejs_compat', 'nodejs_compat_populate_process_env'],
+        workers_dev: true,
+        observability: { enabled: true },
+    };
+    if (opts.route) {
+        config.routes = [{ pattern: opts.route, custom_domain: true }];
+    }
+    if (opts.hasClient) {
+        config.assets = {
+            directory: '../dist-client',
+            binding: 'ASSETS',
+            not_found_handling: 'single-page-application',
+            run_worker_first: true,
+        };
+    }
+    if (opts.selfBinding) {
+        config.services = [{ binding: 'SELF', service: opts.workerName }];
+    }
+    if (opts.vars && Object.keys(opts.vars).length > 0) {
+        config.vars = opts.vars;
+    }
+    const merged = opts.wrangler ? mergeUserConfig(config, opts.wrangler) : config;
+    return JSON.stringify(merged, null, 2) + '\n';
+}
+/** Keys the adapter owns and won't let `params.wrangler` clobber. */
+const ADAPTER_OWNED_KEYS = ['name', 'main', 'assets', 'routes'];
+/**
+ * Deep-merge the dev's raw wrangler overlay over the generated config, after
+ * refusing any attempt to override an adapter-owned key. Throwing (rather than
+ * silently dropping) keeps a stray `main` from breaking the Worker unnoticed.
+ */
+function mergeUserConfig(base, user) {
+    const collisions = ADAPTER_OWNED_KEYS.filter((k) => k in user);
+    if (collisions.length > 0) {
+        throw new Error(`wrangler: cannot override adapter-managed key(s): ${collisions.join(', ')}. ` +
+            'Use `workerName` for the worker name and `route` for routing; ' +
+            '`main` and `assets` are generated by the adapter.');
+    }
+    return deepMergeConfig(base, user);
+}
+//# sourceMappingURL=wrangler.js.map

package/dist/codegen/wrangler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrangler.js","sourceRoot":"","sources":["../../src/codegen/wrangler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAsBzC,MAAM,kBAAkB,GAAG,YAAY,CAAA;AAEvC,MAAM,UAAU,sBAAsB,CAAC,IAA4B;IACjE,MAAM,MAAM,GAA4B;QACtC,IAAI,EAAE,IAAI,CAAC,UAAU;QACrB,IAAI,EAAE,iBAAiB;QACvB,kBAAkB,EAAE,kBAAkB;QACtC,mBAAmB,EAAE,CAAC,eAAe,EAAE,oCAAoC,CAAC;QAC5E,WAAW,EAAE,IAAI;QACjB,aAAa,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE;KACjC,CAAA;IAED,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAA;IAChE,CAAC;IAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,MAAM,CAAC,MAAM,GAAG;YACd,SAAS,EAAE,gBAAgB;YAC3B,OAAO,EAAE,QAAQ;YACjB,kBAAkB,EAAE,yBAAyB;YAC7C,gBAAgB,EAAE,IAAI;SACvB,CAAA;IACH,CAAC;IAED,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,MAAM,CAAC,QAAQ,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,CAAA;IACnE,CAAC;IAED,IAAI,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnD,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAA;IACzB,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,CAAA;IAC9E,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAA;AAC/C,CAAC;AAED,qEAAqE;AACrE,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;AAE/D;;;;GAIG;AACH,SAAS,eAAe,CACtB,IAA6B,EAC7B,IAA6B;IAE7B,MAAM,UAAU,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAA;IAC9D,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CACb,qDAAqD,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;YAC5E,gEAAgE;YAChE,mDAAmD,CACtD,CAAA;IACH,CAAC;IACD,OAAO,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;AACpC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `@astrale-os/adapter-cloudflare` — deploy an Astrale domain as a standalone
+ * Cloudflare Worker.
+ *
+ *   import { cloudflare } from '@astrale-os/adapter-cloudflare'
+ *
+ *   adapter: cloudflare({
+ *     dev:  { secrets: '.env.dev' },
+ *     prod: { route: 'crm.acme.dev', secrets: '.env.prod' },
+ *   })
+ *
+ * `dev` runs `wrangler dev` locally; an env with no `route` ships to
+ * `*.workers.dev`; an env with a `route` ships to that custom domain.
+ */
+export { astrale } from './astrale';
+export { cloudflare } from './cloudflare';
+export type { AstraleParams, CloudflareParams } from './params';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -0,0 +1,17 @@
+/**
+ * `@astrale-os/adapter-cloudflare` — deploy an Astrale domain as a standalone
+ * Cloudflare Worker.
+ *
+ *   import { cloudflare } from '@astrale-os/adapter-cloudflare'
+ *
+ *   adapter: cloudflare({
+ *     dev:  { secrets: '.env.dev' },
+ *     prod: { route: 'crm.acme.dev', secrets: '.env.prod' },
+ *   })
+ *
+ * `dev` runs `wrangler dev` locally; an env with no `route` ships to
+ * `*.workers.dev`; an env with a `route` ships to that custom domain.
+ */
+export { astrale } from './astrale';
+export { cloudflare } from './cloudflare';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA"}

package/dist/params.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `CloudflareParams` — the provider-typed config for the Cloudflare adapter.
+ *
+ * One type covers every env; per-env differences are just optional fields. The
+ * same `{ dev, prod, canary, … }` map a developer writes in `astrale.config.ts`
+ * is `Record<string, CloudflareParams>`.
+ *
+ * Three deployment shapes fall out of which fields are set:
+ *   • dev (local)      — `watch()` runs `wrangler dev`; URL = http://localhost:<port>
+ *   • dev-remote       — `deploy()` with no `route`; URL = https://<name>.<sub>.workers.dev
+ *   • remote (custom)  — `deploy()` with `route`; URL = https://<route>
+ */
+export interface CloudflareParams {
+    /**
+     * Custom route / hostname for a routed deploy, e.g. `'crm.acme.dev'`. Omit to
+     * deploy to `*.workers.dev`. Ignored by local `wrangler dev` (URL is
+     * localhost) but still used as the placeholder base domain there.
+     */
+    route?: string;
+    /** Gitignored secrets file (whole contents = secrets), e.g. `'.env.dev'`. */
+    secrets?: string;
+    /** Local dev port for `wrangler dev`. Default 8787. */
+    port?: number;
+    /** Override the Worker name. Default: derived from the domain origin. */
+    workerName?: string;
+    /** Run `wrangler dev --remote` (edge isolate) instead of local workerd. */
+    remote?: boolean;
+    /** Extra plain (non-secret) vars to inject as Worker vars. */
+    vars?: Record<string, string>;
+    /**
+     * Escape hatch: raw wrangler config deep-merged over the generated base. Use
+     * it to declare extra bindings the adapter has no typed field for — KV, R2,
+     * D1, queues, service bindings, extra `compatibility_flags`, cron `triggers`,
+     * Hyperdrive, etc.
+     *
+     *   wrangler: {
+     *     kv_namespaces: [{ binding: 'CACHE', id: '<kv-id>' }],
+     *     r2_buckets: [{ binding: 'FILES', bucket_name: 'my-bucket' }],
+     *   }
+     *
+     * The merge is additive: arrays concat (so your `services` keep the adapter's
+     * `SELF` binding and your `compatibility_flags` keep `nodejs_compat`); new
+     * keys are added as-is. The adapter-owned keys `name`, `main`, `assets`,
+     * `routes` are rejected — use `workerName` and `route` instead. Avoid
+     * the reserved binding names `SELF` and `ASSETS`. Durable Objects need extra
+     * worker-entry codegen and aren't supported through this field yet.
+     */
+    wrangler?: Record<string, unknown>;
+}
+/** Params for the Astrale-managed adapter (`astrale(envs)`). */
+export interface AstraleParams {
+    /** Target instance slug the domain installs onto (e.g. `'bryan-e2e5'`). */
+    instance: string;
+    /** Catalog package name. Default: the origin's first DNS label. */
+    name?: string;
+    /** Admin kernel URL the publish calls target. Default the platform admin. */
+    adminUrl?: string;
+    /** Routing region of the `.svc` service URL. Default `'eu'`. */
+    region?: string;
+    /** CLI identity (`--as`) for the publish calls. Default: the CLI's active identity. */
+    identity?: string;
+    /** Gitignored secrets file — injected ONLY into local `watch` (managed services receive no secrets yet). */
+    secrets?: string;
+    /** Local dev port for `wrangler dev`. Default 8787. */
+    port?: number;
+    /** Extra plain vars for local `watch`. */
+    vars?: Record<string, string>;
+}
+//# sourceMappingURL=params.d.ts.map

package/dist/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../src/params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED,gEAAgE;AAChE,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAA;IAChB,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,uFAAuF;IACvF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,4GAA4G;IAC5G,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B"}

package/dist/params.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=params.js.map

package/dist/params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.js","sourceRoot":"","sources":["../src/params.ts"],"names":[],"mappings":""}

package/dist/parse-output.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure parsers for `wrangler` stdout. Kept separate from the process-spawning in
+ * `wrangler-cli.ts` so the brittle bit — scraping wrangler's human output — is
+ * unit-testable against captured fixtures without shelling out.
+ */
+/**
+ * Local dev URL from `wrangler dev` output, normalized to an origin on the given
+ * port. Returns `undefined` when the output hasn't reported readiness yet.
+ *
+ * The fallback (when no explicit "Ready on" line) only accepts a localhost URL
+ * on the EXPECTED port — wrangler may print unrelated localhost URLs (e.g. an
+ * inspector/devtools endpoint on a different port) before readiness, and taking
+ * one of those would point `astrale instance install <url>` at a dead endpoint.
+ */
+export declare function parseDevReadyUrl(text: string, port: number): string | undefined;
+/**
+ * Authoritative public URL from `wrangler deploy` output. A custom-domain
+ * `route` wins (the deploy attaches it); otherwise the printed `*.workers.dev`
+ * URL. Returns `undefined` when neither is available (caller surfaces the raw
+ * output).
+ */
+export declare function parseDeployUrl(text: string, route?: string): string | undefined;
+/** Normalize a local dev URL to an origin: `0.0.0.0` → `localhost`, fill the port. */
+export declare function normalizeLocal(url: string, port: number): string;
+//# sourceMappingURL=parse-output.d.ts.map

package/dist/parse-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-output.d.ts","sourceRoot":"","sources":["../src/parse-output.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAW/E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAI/E;AAED,sFAAsF;AACtF,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAShE"}

package/dist/parse-output.js

@@ -0,0 +1,53 @@
+/**
+ * Pure parsers for `wrangler` stdout. Kept separate from the process-spawning in
+ * `wrangler-cli.ts` so the brittle bit — scraping wrangler's human output — is
+ * unit-testable against captured fixtures without shelling out.
+ */
+const READY_RE = /(?:Ready on|Listening on|⎔.*?at)\s+(https?:\/\/[^\s]+)/i;
+const WORKERS_DEV_RE = /(https:\/\/[^\s]+\.workers\.dev)/i;
+/**
+ * Local dev URL from `wrangler dev` output, normalized to an origin on the given
+ * port. Returns `undefined` when the output hasn't reported readiness yet.
+ *
+ * The fallback (when no explicit "Ready on" line) only accepts a localhost URL
+ * on the EXPECTED port — wrangler may print unrelated localhost URLs (e.g. an
+ * inspector/devtools endpoint on a different port) before readiness, and taking
+ * one of those would point `astrale instance install <url>` at a dead endpoint.
+ */
+export function parseDevReadyUrl(text, port) {
+    const ready = READY_RE.exec(text);
+    if (ready)
+        return normalizeLocal(ready[1], port);
+    // `port` is a number, so it's safe to interpolate into the pattern. The
+    // negative lookahead stops `:8787` from matching inside `:87870`.
+    const localhostOnPort = new RegExp(`(https?://(?:localhost|127\\.0\\.0\\.1):${port})(?![0-9])`, 'i');
+    const m = localhostOnPort.exec(text);
+    return m ? normalizeLocal(m[1], port) : undefined;
+}
+/**
+ * Authoritative public URL from `wrangler deploy` output. A custom-domain
+ * `route` wins (the deploy attaches it); otherwise the printed `*.workers.dev`
+ * URL. Returns `undefined` when neither is available (caller surfaces the raw
+ * output).
+ */
+export function parseDeployUrl(text, route) {
+    if (route)
+        return `https://${route.replace(/\/.*$/, '')}`;
+    const m = WORKERS_DEV_RE.exec(text);
+    return m ? m[1] : undefined;
+}
+/** Normalize a local dev URL to an origin: `0.0.0.0` → `localhost`, fill the port. */
+export function normalizeLocal(url, port) {
+    try {
+        const u = new URL(url);
+        if (u.hostname === '0.0.0.0')
+            u.hostname = 'localhost';
+        if (!u.port)
+            u.port = String(port);
+        return u.origin;
+    }
+    catch {
+        return `http://localhost:${port}`;
+    }
+}
+//# sourceMappingURL=parse-output.js.map

package/dist/parse-output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-output.js","sourceRoot":"","sources":["../src/parse-output.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,QAAQ,GAAG,yDAAyD,CAAA;AAC1E,MAAM,cAAc,GAAG,mCAAmC,CAAA;AAE1D;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY,EAAE,IAAY;IACzD,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACjC,IAAI,KAAK;QAAE,OAAO,cAAc,CAAC,KAAK,CAAC,CAAC,CAAE,EAAE,IAAI,CAAC,CAAA;IACjD,wEAAwE;IACxE,kEAAkE;IAClE,MAAM,eAAe,GAAG,IAAI,MAAM,CAChC,2CAA2C,IAAI,YAAY,EAC3D,GAAG,CACJ,CAAA;IACD,MAAM,CAAC,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACpC,OAAO,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AACpD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY,EAAE,KAAc;IACzD,IAAI,KAAK;QAAE,OAAO,WAAW,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,EAAE,CAAA;IACzD,MAAM,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACnC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AAC7B,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,cAAc,CAAC,GAAW,EAAE,IAAY;IACtD,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAA;QACtB,IAAI,CAAC,CAAC,QAAQ,KAAK,SAAS;YAAE,CAAC,CAAC,QAAQ,GAAG,WAAW,CAAA;QACtD,IAAI,CAAC,CAAC,CAAC,IAAI;YAAE,CAAC,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;QAClC,OAAO,CAAC,CAAC,MAAM,CAAA;IACjB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,oBAAoB,IAAI,EAAE,CAAA;IACnC,CAAC;AACH,CAAC"}

package/dist/wrangler-cli.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Thin wrapper around the `wrangler` binary — the only place the adapter shells
+ * out. `watch` runs `wrangler dev` (local workerd) and resolves once the worker
+ * reports its local URL; `deploy` runs `wrangler deploy` and parses the
+ * authoritative public URL from the output; secrets go through `wrangler secret
+ * bulk`. The wrangler binary is resolved from the project's `node_modules/.bin`,
+ * falling back to `npx wrangler`.
+ */
+export interface DevHandle {
+    url: string;
+    stop(): Promise<void>;
+}
+export declare function runWranglerDev(args: {
+    projectDir: string;
+    configPath: string;
+    port: number;
+    remote: boolean;
+    onReload: () => void;
+    onLog?: (line: string) => void;
+}): Promise<DevHandle>;
+export interface DeployArgs {
+    configPath: string;
+    /** SELF-less config for the first-deploy two-pass (see `deployWithSelfFallback`). */
+    fallbackConfigPath?: string;
+    /** The worker's own name, to scope the self-binding-missing detection. */
+    workerName?: string;
+    route?: string;
+    onLog?: (line: string) => void;
+}
+export declare function runWranglerDeploy(args: DeployArgs & {
+    projectDir: string;
+}): Promise<{
+    url: string;
+    raw: string;
+}>;
+/**
+ * Deploy with a one-time SELF-binding first-deploy recovery. A fresh worker that
+ * declares a `services: SELF` binding can't deploy (its own script doesn't exist
+ * yet); on THAT specific failure we deploy the SELF-less fallback to create the
+ * script, then redeploy WITH SELF so autobinding works. Steady state (every
+ * deploy after the first) is a single pass. The `deploy` runner is injected so
+ * the orchestration is unit-testable without shelling out.
+ */
+export declare function deployWithSelfFallback(deploy: (configPath: string) => Promise<{
+    code: number;
+    out: string;
+}>, args: DeployArgs): Promise<{
+    url: string;
+    raw: string;
+}>;
+/**
+ * True when wrangler failed specifically because the worker's OWN `SELF` service
+ * binding can't resolve yet (first deploy of a fresh script). Requires the
+ * worker name so an unrelated missing-service error doesn't trigger the two-pass.
+ */
+export declare function isSelfBindingMissing(out: string, workerName?: string): boolean;
+export declare function bulkPutSecrets(args: {
+    projectDir: string;
+    configPath: string;
+    secrets: Record<string, string>;
+    onLog?: (line: string) => void;
+}): Promise<void>;
+/**
+ * Build the single-module worker bundle WITHOUT deploying — `wrangler deploy
+ * --dry-run --outdir` (no Cloudflare auth required). Returns the path of the
+ * bundled .js module (the managed adapter publishes its bytes).
+ */
+export declare function runWranglerBundle(args: {
+    projectDir: string;
+    configPath: string;
+    outDir: string;
+    onLog?: (line: string) => void;
+}): Promise<string>;
+//# sourceMappingURL=wrangler-cli.d.ts.map

package/dist/wrangler-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrangler-cli.d.ts","sourceRoot":"","sources":["../src/wrangler-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAkBH,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACtB;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/B,GAAG,OAAO,CAAC,SAAS,CAAC,CAkErB;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,qFAAqF;IACrF,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/B;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,UAAU,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GACxC,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAKvC;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,EACtE,IAAI,EAAE,UAAU,GACf,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,CAwBvC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAO9E;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE;IACzC,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/B,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBhB;AAyCD;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAC5C,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/B,GAAG,OAAO,CAAC,MAAM,CAAC,CAalB"}