@jk2908/solas 0.8.0-canary.1791495022678 → 0.8.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 0.8.0
 
 ### Features
 

package/dist/adapters/cloudflare/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { Assets } from '../../internal/runtimes/assets.js';
+import type { AssetNamespace, Assets } from '../../internal/runtimes/assets.js';
 /**
  * The subset of the Cloudflare `assets` Fetcher binding that Solas needs.
  */
@@ -13,17 +13,20 @@ export type CloudflareEnv = {
     [key: string]: unknown;
 };
 /**
- * Path prefix the adapter copies `dist/.solas` prerender artifacts under in the
- * asset output.
+ * Path prefix the adapter copies `dist/.solas` artifacts under in the asset
+ * output.
  */
 export declare const ARTIFACT_PREFIX = "_solas-artifacts";
 /**
- * Prerendered documents live under the artifact prefix rather than the asset
- * root. If they sat at their route paths the asset layer would serve them for
- * every request to that path, so an RSC navigation (`Accept:
- * text/x-component`) would receive HTML instead of reaching the Worker.
+ * Where each namespace lives in the asset output, keyed by the shared
+ * `AssetNamespace`. `client` files sit at the asset root; `static` (prerenders)
+ * and `artifact` (manifest, ppr) live under the artifact prefix.
+ *
+ * Prerenders must not sit at their route paths: the asset layer ignores
+ * `Accept`, so it would answer an RSC navigation (`Accept: text/x-component`)
+ * with HTML instead of letting the Worker render it.
  */
-export declare const PRERENDER_PREFIX = "_solas-artifacts/static";
+export declare const NAMESPACE_PREFIX: Record<AssetNamespace, string>;
 /**
  * Create a Solas asset store backed by the Cloudflare assets binding.
  *

package/dist/adapters/cloudflare/runtime.js

@@ -1,19 +1,26 @@
 import { getMimeTypeFromPath } from '../../internal/runtimes/mime.js';
 /**
- * Path prefix the adapter copies `dist/.solas` prerender artifacts under in the
- * asset output.
+ * Path prefix the adapter copies `dist/.solas` artifacts under in the asset
+ * output.
  */
 export const ARTIFACT_PREFIX = '_solas-artifacts';
-/**
- * Prerendered documents live under the artifact prefix rather than the asset
- * root. If they sat at their route paths the asset layer would serve them for
- * every request to that path, so an RSC navigation (`Accept:
- * text/x-component`) would receive HTML instead of reaching the Worker.
- */
-export const PRERENDER_PREFIX = `${ARTIFACT_PREFIX}/static`;
 // The assets binding matches on pathname only, so this is only used to satisfy
 // the URL constructor
 const ASSET_ORIGIN = 'https://solas-assets.invalid';
+/**
+ * Where each namespace lives in the asset output, keyed by the shared
+ * `AssetNamespace`. `client` files sit at the asset root; `static` (prerenders)
+ * and `artifact` (manifest, ppr) live under the artifact prefix.
+ *
+ * Prerenders must not sit at their route paths: the asset layer ignores
+ * `Accept`, so it would answer an RSC navigation (`Accept: text/x-component`)
+ * with HTML instead of letting the Worker render it.
+ */
+export const NAMESPACE_PREFIX = {
+    client: '',
+    static: `${ARTIFACT_PREFIX}/static`,
+    artifact: ARTIFACT_PREFIX,
+};
 /**
  * Create a Solas asset store backed by the Cloudflare assets binding.
  *
@@ -26,47 +33,36 @@ export function createCloudflareAssets(env) {
     if (!assets || typeof assets.fetch !== 'function') {
         throw new Error('[solas] createCloudflareAssets requires an `ASSETS` binding. Add an assets binding to your Worker.');
     }
-    /**
-     * Where each namespace lives in the asset output: `client` files sit at the
-     * asset root, prerenders and artifacts under the artifact prefix.
-     */
-    function toAssetPath(asset) {
-        switch (asset.namespace) {
-            case 'artifact':
-                return `${ARTIFACT_PREFIX}/${asset.path}`;
-            case 'static':
-                return `${PRERENDER_PREFIX}/${asset.path}`;
-            default:
-                return asset.path;
-        }
-    }
+    // narrowed here, and `const` keeps that type inside the closures below
+    const binding = assets;
     function toUrl(asset) {
-        return new URL(`/${toAssetPath(asset)}`, ASSET_ORIGIN).toString();
+        const prefix = NAMESPACE_PREFIX[asset.namespace];
+        const path = prefix ? `${prefix}/${asset.path}` : asset.path;
+        return new URL(`/${path}`, ASSET_ORIGIN).toString();
     }
     async function read(asset) {
-        const res = await assets.fetch(toUrl(asset), {
+        const res = await binding.fetch(toUrl(asset), {
             // asset responses should be passed through verbatim
             headers: { 'accept-encoding': 'identity' },
         });
         return res.ok ? res : null;
     }
+    async function readOrThrow(asset) {
+        const res = await read(asset);
+        if (!res) {
+            throw new Error(`[solas] asset not found: ${asset.namespace}/${asset.path}`);
+        }
+        return res;
+    }
     return {
         async exists(asset) {
             return (await read(asset)) !== null;
         },
         async readText(asset) {
-            const res = await read(asset);
-            if (!res) {
-                throw new Error(`[solas] asset not found: ${asset.namespace}/${asset.path}`);
-            }
-            return res.text();
+            return (await readOrThrow(asset)).text();
         },
         async readBuffer(asset) {
-            const res = await read(asset);
-            if (!res) {
-                throw new Error(`[solas] asset not found: ${asset.namespace}/${asset.path}`);
-            }
-            return res.arrayBuffer();
+            return (await readOrThrow(asset)).arrayBuffer();
         },
         mimeType(filePath) {
             return getMimeTypeFromPath(filePath);

package/dist/adapters/cloudflare/vite.js

@@ -4,7 +4,7 @@ import { cloudflare as cloudflareVitePlugin } from '@cloudflare/vite-plugin';
 import * as Config from '../../config.js';
 import { writeCloudflareEntry } from '../../internal/codegen/environments.js';
 import { setRscEntry } from '../../internal/postbuild.js';
-import { ARTIFACT_PREFIX, PRERENDER_PREFIX } from './runtime.js';
+import { NAMESPACE_PREFIX } from './runtime.js';
 const VIRTUAL_ENTRY = 'virtual:solas-cloudflare-entry';
 /**
  * Solas dependencies that are imported at request time from the Worker
@@ -56,13 +56,13 @@ async function copyOutput(cwd) {
     const assetDirs = await findAssetDirs(path.join(cwd, '.cloudflare', 'output'));
     for (const assetDir of assetDirs) {
         if (await pathExists(artifactSource)) {
-            await fs.cp(artifactSource, path.join(assetDir, ARTIFACT_PREFIX), {
+            await fs.cp(artifactSource, path.join(assetDir, NAMESPACE_PREFIX.artifact), {
                 recursive: true,
                 force: true,
             });
         }
         if (await pathExists(staticSource)) {
-            await fs.cp(staticSource, path.join(assetDir, PRERENDER_PREFIX), {
+            await fs.cp(staticSource, path.join(assetDir, NAMESPACE_PREFIX.static), {
                 recursive: true,
                 force: true,
             });

package/dist/adapters/cloudflare/worker.js

@@ -1,4 +1,4 @@
-import { createHandler, loadManifest } from '../../internal/env/rsc.js';
+import { createRuntimeHandler } from '../../internal/env/rsc.js';
 import { nodeAssets } from '../../internal/runtimes/assets.js';
 import { createCloudflareAssets } from './runtime.js';
 /**
@@ -13,11 +13,7 @@ export function createWorker(options) {
     const handlers = new WeakMap();
     let nodeHandler;
     async function build(assets) {
-        const runtimeManifest = await loadManifest(assets);
-        return createHandler(options.config, options.manifest, options.importMap, {
-            assets,
-            runtimeManifest,
-        });
+        return createRuntimeHandler(options.config, options.manifest, options.importMap, assets);
     }
     function getHandler(env) {
         if (!env) {

package/dist/internal/codegen/environments.js

@@ -7,15 +7,13 @@ export function writeRSCEntry(_config) {
     return source `
 		${AUTOGEN_MSG}
 
-		import { createHandler, loadManifest } from '${Config.PKG_NAME}/env/rsc'
+		import { createRuntimeHandler } from '${Config.PKG_NAME}/env/rsc'
 
 		import { manifest } from './manifest.js'
 		import { importMap } from './maps.js'
 		import { config } from './config.js'
 
-		const runtimeManifest = await loadManifest()
-
-		export default createHandler(config, manifest, importMap, { runtimeManifest })
+		export default await createRuntimeHandler(config, manifest, importMap)
 
 		if (import.meta.hot) {
 			import.meta.hot.accept()

package/dist/internal/env/rsc.d.ts

@@ -38,3 +38,14 @@ export type RscPayload = {
 export declare function createHandler(config: RuntimeConfig, manifest: Manifest, importMap: ImportMap, options?: HandlerOptions): {
     fetch(req: Request): Promise<Response>;
 };
+/**
+ * Build a Solas request handler over an {@link Assets} store.
+ *
+ * Loads the runtime manifest and constructs the RSC handler, defaulting to the
+ * Node standard library for assets. Platform adapters pass their own store (for
+ * example the Cloudflare `ASSETS` binding), so the same generated entry runs
+ * unchanged across runtimes.
+ */
+export declare function createRuntimeHandler(config: RuntimeConfig, manifest: Manifest, importMap: ImportMap, assets?: Assets): Promise<{
+    fetch(req: Request): Promise<Response>;
+}>;

package/dist/internal/env/rsc.js

@@ -3,6 +3,7 @@ import { renderToReadableStream } from '@vitejs/plugin-rsc/rsc';
 import { applyBasePath, normaliseBasePath, stripBasePath } from '../../utils/base-path.js';
 import { Logger } from '../../utils/logger.js';
 import * as Config from '../../config.js';
+import * as RuntimeManifest from '../../manifest.js';
 import { createHttpRouter } from '../http-router/create-http-router.js';
 import { HttpRouter } from '../http-router/router.js';
 import { normalisePathname } from '../http-router/utils.js';
@@ -412,6 +413,18 @@ export function createHandler(config, manifest, importMap, options = {}) {
         },
     };
 }
+/**
+ * Build a Solas request handler over an {@link Assets} store.
+ *
+ * Loads the runtime manifest and constructs the RSC handler, defaulting to the
+ * Node standard library for assets. Platform adapters pass their own store (for
+ * example the Cloudflare `ASSETS` binding), so the same generated entry runs
+ * unchanged across runtimes.
+ */
+export async function createRuntimeHandler(config, manifest, importMap, assets = nodeAssets) {
+    const runtimeManifest = await RuntimeManifest.loadManifest(assets);
+    return createHandler(config, manifest, importMap, { assets, runtimeManifest });
+}
 function onError(err) {
     if (err == null)
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jk2908/solas",
-	"version": "0.8.0-canary.1791495022678",
+	"version": "0.8.0",
 	"description": "A Vite + React meta-framework exploring streaming, Server Components, and partial prerendering. Designed for simplicity and lightness",
 	"keywords": [
 		"framework",