@isoloop/vite 0.0.0-next.4da23df

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sabin Pandelovitch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/client.d.ts

@@ -0,0 +1,20 @@
+// Types for the modules `@isoloop/vite` provides. Reference it from the app:
+// `/// <reference types="@isoloop/vite/client" />`.
+
+/** `KernelConfig.workers`: the bootstrap's URL, and the bus worker's unless `bus: false`. */
+declare module 'virtual:isoloop/workers' {
+  const workers: { isolateBootstrap: string; bus?: string };
+  export default workers;
+}
+
+/** URLs of the isolates listed in `isoloop({ isolates })`, by name. */
+declare module 'virtual:isoloop/isolates' {
+  const isolates: Record<string, string>;
+  export default isolates;
+}
+
+/** The URL of an isolate module (or the contracts module), for `spawn({ src })`. */
+declare module '*?isolate' {
+  const url: string;
+  export default url;
+}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { Plugin } from "vite";
+export declare const ISOLATES_ID = "virtual:isoloop/isolates";
+export declare const MANIFEST = "isoloop-manifest.json";
+type BuildOptions = {
+  /** Isolate entries by name, relative to the Vite root. */
+  isolates?: Readonly<Record<string, string>>;
+  /** Build only the isolates (library mode), not an app. Needs `isolates`. */
+  library?: boolean;
+};
+/** What `isoloop-manifest.json` holds: each isolate's file, relative to the output directory. */
+type IsolateManifest = {
+  isolates: Record<string, string>;
+};
+export declare const WORKERS_ID = "virtual:isoloop/workers";
+type HeaderOptions = {
+  /**
+   * The Content-Security-Policy to send, or `false` for none. Default: the
+   * hosting guide's policy, with `isolateOrigins` in `script-src` and
+   * `connect-src`, plus what Vite's dev server needs (its HMR socket and
+   * injected styles).
+   */
+  csp?: string | false;
+  /** Origins that serve isolate modules or the contracts module. */
+  isolateOrigins?: readonly string[];
+  /** Sends COOP `same-origin` and COEP `require-corp`, for `SharedArrayBuffer`. Default false. */
+  crossOriginIsolated?: boolean;
+};
+type WorkersOptions = {
+  /** Include the bus worker's URL. Default true; an app without `contracts` can drop it. */
+  bus?: boolean;
+};
+/** The policy for the dev server: the hosting guide's, plus Vite's HMR socket and injected styles. */
+export declare function devCsp(origins?: readonly string[]): string;
+export declare function headersFor(o: HeaderOptions): Record<string, string>;
+export type IsoloopOptions = HeaderOptions & WorkersOptions & BuildOptions;
+export declare function isoloop(o?: IsoloopOptions): Plugin[];
+export type { BuildOptions, HeaderOptions, IsolateManifest, WorkersOptions };

package/dist/index.js

@@ -0,0 +1,134 @@
+import { relative, resolve } from "node:path";
+// src/build.ts
+const QUERY = "?isolate";
+const PREFIX = "\0isolate:";
+const ISOLATES_ID = "virtual:isoloop/isolates";
+const RESOLVED$1 = `\0${ISOLATES_ID}`;
+const MANIFEST = "isoloop-manifest.json";
+function buildPlugin(o) {
+	const isolates = o.isolates ?? {};
+	let root = process.cwd();
+	let serve = false;
+	/** Emitted chunk refs by isolate name (app builds). */
+	const refs = /* @__PURE__ */ new Map();
+	return {
+		name: "isoloop:build",
+		enforce: "pre",
+		config() {
+			if (!o.library) return void 0;
+			if (Object.keys(isolates).length === 0) throw new Error("@isoloop/vite: library mode needs `isolates`");
+			return { build: { lib: {
+				entry: { ...isolates },
+				formats: ["es"],
+				fileName: (_format, name) => `${name}.js`
+			} } };
+		},
+		configResolved(c) {
+			root = c.root;
+			serve = c.command === "serve";
+		},
+		buildStart() {
+			if (serve || o.library) return;
+			for (const [name, entry] of Object.entries(isolates)) refs.set(name, this.emitFile({
+				type: "chunk",
+				id: resolve(root, entry),
+				name,
+				preserveSignature: "strict"
+			}));
+		},
+		async resolveId(source, importer) {
+			if (source === "virtual:isoloop/isolates") return RESOLVED$1;
+			if (!source.endsWith(QUERY)) return null;
+			const r = await this.resolve(source.slice(0, -8), importer);
+			return r ? PREFIX + r.id : null;
+		},
+		load(id) {
+			if (id === RESOLVED$1) {
+				const names = Object.keys(isolates);
+				return [...names.map((n, i) => `import u${i} from ${JSON.stringify(`${resolve(root, isolates[n] ?? "")}${QUERY}`)};`), `export default { ${names.map((n, i) => `${JSON.stringify(n)}: u${i}`).join(", ")} };`].join("\n");
+			}
+			if (!id.startsWith(PREFIX)) return null;
+			const file = id.slice(9);
+			if (serve) {
+				const rel = relative(root, file);
+				const url = rel.startsWith("..") ? `/@fs${file}` : `/${rel.split("\\").join("/")}`;
+				return `export default ${JSON.stringify(url)};`;
+			}
+			return `export default import.meta.ROLLUP_FILE_URL_${this.emitFile({
+				type: "chunk",
+				id: file,
+				preserveSignature: "strict"
+			})};`;
+		},
+		generateBundle(_opts, bundle) {
+			if (Object.keys(isolates).length === 0) return;
+			const manifest = { isolates: {} };
+			if (o.library) {
+				for (const chunk of Object.values(bundle)) if (chunk.type === "chunk" && chunk.isEntry && chunk.name in isolates) manifest.isolates[chunk.name] = chunk.fileName;
+			} else for (const [name, ref] of refs) manifest.isolates[name] = this.getFileName(ref);
+			this.emitFile({
+				type: "asset",
+				fileName: MANIFEST,
+				source: `${JSON.stringify(manifest, null, 2)}\n`
+			});
+		}
+	};
+}
+// src/dev.ts
+const WORKERS_ID = "virtual:isoloop/workers";
+const RESOLVED = `\0${WORKERS_ID}`;
+/** The policy for the dev server: the hosting guide's, plus Vite's HMR socket and injected styles. */
+function devCsp(origins = []) {
+	const extra = origins.length > 0 ? ` ${origins.join(" ")}` : "";
+	return [
+		"default-src 'self'",
+		"worker-src 'self'",
+		`script-src 'self'${extra}`,
+		`connect-src 'self' ws: wss:${extra}`,
+		"style-src 'self' 'unsafe-inline'"
+	].join("; ");
+}
+function headersFor(o) {
+	const headers = {};
+	const csp = o.csp ?? devCsp(o.isolateOrigins);
+	if (csp !== false) headers["Content-Security-Policy"] = csp;
+	if (o.crossOriginIsolated) {
+		headers["Cross-Origin-Opener-Policy"] = "same-origin";
+		headers["Cross-Origin-Embedder-Policy"] = "require-corp";
+	}
+	return headers;
+}
+/**
+* `virtual:isoloop/workers` (the two worker entries go through Vite's own
+* `?worker&url`, so dev serves them and a build emits them), and the headers.
+*/
+function devPlugin(o) {
+	const headers = headersFor(o);
+	const use = (server) => {
+		server.middlewares.use((_req, res, next) => {
+			for (const [k, v] of Object.entries(headers)) res.setHeader(k, v);
+			next();
+		});
+	};
+	return {
+		name: "isoloop:dev",
+		config: () => ({ worker: { format: "es" } }),
+		resolveId: (id) => id === "virtual:isoloop/workers" ? RESOLVED : null,
+		load(id) {
+			if (id !== RESOLVED) return null;
+			const bus = o.bus ?? true;
+			return [
+				"import isolateBootstrap from '@isoloop/runtime/bootstrap?worker&url';",
+				...bus ? ["import bus from '@isoloop/bus/worker?worker&url';"] : [],
+				`export default { isolateBootstrap${bus ? ", bus" : ""} };`
+			].join("\n");
+		},
+		configureServer: use,
+		configurePreviewServer: use
+	};
+}
+// src/index.ts
+function isoloop(o = {}) {
+	return [buildPlugin(o), ...o.library ? [] : [devPlugin(o)]];
+}
+export { ISOLATES_ID, MANIFEST, WORKERS_ID, devCsp, headersFor, isoloop };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@isoloop/vite",
+  "version": "0.0.0-next.4da23df",
+  "description": "Vite plugin for Isoloop apps: the bootstrap and bus worker URLs, dev headers, and isolate builds.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/isoloop/isoloop.git",
+    "directory": "packages/vite"
+  },
+  "files": [
+    "dist",
+    "client.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./client.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "vite": "^8"
+  },
+  "devDependencies": {
+    "@isoloop/bus": "0.0.0-next.4da23df",
+    "@isoloop/runtime": "0.0.0-next.4da23df",
+    "@types/node": "26.6.6",
+    "typescript": "7.0.2",
+    "vite": "8.3.5"
+  },
+  "scripts": {
+    "build": "tsdown --platform node --dts --no-fixed-extension",
+    "typecheck": "tsc --noEmit"
+  }
+}