@farm.js/federation 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Farm.js Team
+
+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/README.md

@@ -0,0 +1,38 @@
+# @farm.js/federation
+
+Publish and consume independently deployed browser modules from Farm applications.
+
+```bash
+pnpm add @farm.js/federation
+```
+
+```ts
+import { defineConfig } from "@farm.js/core";
+import { federation } from "@farm.js/federation";
+
+export default defineConfig({
+  plugins: [
+    federation({
+      name: "storefront",
+      remotes: {
+        checkout: "https://checkout.example.com/mf-manifest.json",
+      },
+    }),
+  ],
+});
+```
+
+Load configured modules after hydration:
+
+```ts
+import { loadRemote } from "@farm.js/federation/client";
+
+const checkout = await loadRemote("checkout/UpgradeCard");
+```
+
+The first release is deliberately browser-only. Server functions, API handlers, Server
+Components, credentials, and other server capabilities stay local to each application. Server
+federation is being designed in [RFC #885](https://github.com/farming-labs/farm.js/issues/885).
+
+Read the [Federation Plugin guide](https://farmjs.dev/docs/plugins/federation) for producer setup,
+typed loading, shared dependencies, deployment, and security guidance.

package/dist/client-runtime.d.ts

@@ -0,0 +1,13 @@
+export interface FederationRuntimeApi {
+    loadRemote<T>(specifier: string): Promise<T | null>;
+    preloadRemote(remotes: Array<{
+        nameOrAlias: string;
+    }>): Promise<unknown>;
+}
+export interface FederationClient {
+    loadRemote<TModule>(specifier: string): Promise<TModule>;
+    preloadRemote(remotes: string | string[]): Promise<void>;
+}
+export type FederationRuntimeLoader = () => Promise<FederationRuntimeApi>;
+export declare function createFederationClient(loadRuntime: FederationRuntimeLoader, isBrowser?: () => boolean): FederationClient;
+//# sourceMappingURL=client-runtime.d.ts.map

package/dist/client-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-runtime.d.ts","sourceRoot":"","sources":["../src/client-runtime.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACpD,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1E;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAED,MAAM,MAAM,uBAAuB,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAE1E,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,uBAAuB,EACpC,SAAS,GAAE,MAAM,OAA6C,GAC7D,gBAAgB,CAqClB"}

package/dist/client-runtime.js

@@ -0,0 +1,54 @@
+export function createFederationClient(loadRuntime, isBrowser = () => typeof window !== "undefined") {
+    let runtime;
+    const getRuntime = () => {
+        if (!isBrowser()) {
+            throw new Error("[farm:federation] Remote browser modules must be loaded after hydration, for example inside an effect or event handler.");
+        }
+        if (!runtime) {
+            const loading = loadRuntime().catch((error) => {
+                runtime = undefined;
+                throw error;
+            });
+            runtime = loading;
+        }
+        return runtime;
+    };
+    return {
+        async loadRemote(specifier) {
+            const normalized = normalizeSpecifier(specifier);
+            const module = await (await getRuntime()).loadRemote(normalized);
+            if (module === null) {
+                throw new Error(`[farm:federation] Remote module ${JSON.stringify(normalized)} was not found`);
+            }
+            return module;
+        },
+        async preloadRemote(remotes) {
+            const values = (Array.isArray(remotes) ? remotes : [remotes]).map(normalizeRemoteName);
+            if (values.length === 0)
+                throw new TypeError("Federation preload requires at least one remote");
+            await (await getRuntime()).preloadRemote(values.map((nameOrAlias) => ({ nameOrAlias })));
+        },
+    };
+}
+function normalizeSpecifier(value) {
+    const specifier = normalizeRemoteName(value);
+    if (!specifier.includes("/") || specifier.endsWith("/")) {
+        throw new TypeError("Federation module specifier must contain a remote and exposed module");
+    }
+    return specifier;
+}
+function normalizeRemoteName(value) {
+    if (typeof value !== "string" ||
+        !value.trim() ||
+        /\s|[?#\\]/.test(value) ||
+        hasControlCharacter(value)) {
+        throw new TypeError("Federation remote names must be non-empty module specifiers");
+    }
+    return value.trim();
+}
+function hasControlCharacter(value) {
+    return Array.from(value).some((character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint <= 0x1f || codePoint === 0x7f;
+    });
+}

package/dist/client.d.ts

@@ -0,0 +1,6 @@
+export type { FederationClient } from "./client-runtime.js";
+/** Load one configured remote browser module after Farm hydration. */
+export declare const loadRemote: <TModule>(specifier: string) => Promise<TModule>;
+/** Preload one or more configured producers before their modules are needed. */
+export declare const preloadRemote: (remotes: string | string[]) => Promise<void>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAU5D,sEAAsE;AACtE,eAAO,MAAM,UAAU,kDAAoB,CAAC;AAE5C,gFAAgF;AAChF,eAAO,MAAM,aAAa,+CAAuB,CAAC"}

package/dist/client.js

@@ -0,0 +1,12 @@
+import { createFederationClient } from "./client-runtime.js";
+const client = createFederationClient(async () => {
+    const runtime = await import("@module-federation/runtime");
+    return {
+        loadRemote: runtime.loadRemote,
+        preloadRemote: runtime.preloadRemote,
+    };
+});
+/** Load one configured remote browser module after Farm hydration. */
+export const loadRemote = client.loadRemote;
+/** Preload one or more configured producers before their modules are needed. */
+export const preloadRemote = client.preloadRemote;

package/dist/config.d.ts

@@ -0,0 +1,60 @@
+import type { ModuleFederationOptions } from "@module-federation/vite";
+export interface FederationRemote {
+    /** URL of the producer's mf-manifest.json or remoteEntry.js. */
+    entry: string;
+    /** Producer name. Defaults to the remote alias. */
+    name?: string;
+    /** Remote entry format. Farm producers use module by default. */
+    type?: string;
+    /** Module Federation share scope used by this producer. */
+    shareScope?: string | string[];
+}
+export interface FederationSharedPackage {
+    singleton?: boolean;
+    requiredVersion?: string | false;
+    strictVersion?: boolean;
+    eager?: boolean;
+    shareScope?: string;
+    import?: string | false;
+}
+export type FederationSharedPackages = string[] | Record<string, true | FederationSharedPackage>;
+export interface FederationSharedOptions {
+    /** Share the active Farm renderer and its browser runtime as singletons. Defaults to true. */
+    renderer?: boolean;
+    /** Additional application packages to share. */
+    packages?: FederationSharedPackages;
+}
+export interface FederationOptions {
+    /** Stable name of this producer or consumer. */
+    name: string;
+    /** Browser modules this application publishes. */
+    exposes?: Record<string, string | {
+        import: string;
+    }>;
+    /** Independently deployed browser producers this application consumes. */
+    remotes?: Record<string, string | FederationRemote>;
+    /** Renderer and application dependencies reused across federated applications. */
+    shared?: "renderer" | false | FederationSharedOptions;
+    /** Generate mf-manifest.json. Defaults to true when modules are exposed. */
+    manifest?: boolean;
+    /** Remote entry filename. */
+    filename?: string;
+    /** Public origin or base URL used in generated federation assets. */
+    publicPath?: string;
+    /** Generate and consume remote TypeScript declarations. Defaults to true. */
+    types?: boolean;
+    /** Development behavior for independently running producers. */
+    dev?: {
+        remoteHmr?: boolean | "full-reload";
+    };
+}
+export interface FederationRenderer {
+    name: string;
+    dedupe?: readonly string[];
+}
+export interface ResolvedFederationOptions {
+    remoteAliases: string[];
+    upstream: ModuleFederationOptions;
+}
+export declare function resolveFederationOptions(options: FederationOptions, renderer: FederationRenderer): ResolvedFederationOptions;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAEvE,MAAM,WAAW,gBAAgB;IAC/B,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iEAAiE;IACjE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CACzB;AAED,MAAM,MAAM,wBAAwB,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,GAAG,uBAAuB,CAAC,CAAC;AAEjG,MAAM,WAAW,uBAAuB;IACtC,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gDAAgD;IAChD,QAAQ,CAAC,EAAE,wBAAwB,CAAC;CACrC;AAED,MAAM,WAAW,iBAAiB;IAChC,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtD,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAAC,CAAC;IACpD,kFAAkF;IAClF,MAAM,CAAC,EAAE,UAAU,GAAG,KAAK,GAAG,uBAAuB,CAAC;IACtD,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,gEAAgE;IAChE,GAAG,CAAC,EAAE;QACJ,SAAS,CAAC,EAAE,OAAO,GAAG,aAAa,CAAC;KACrC,CAAC;CACH;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,yBAAyB;IACxC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,uBAAuB,CAAC;CACnC;AAID,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,iBAAiB,EAC1B,QAAQ,EAAE,kBAAkB,GAC3B,yBAAyB,CA0C3B"}

package/dist/config.js

@@ -0,0 +1,237 @@
+const SERVER_OPTIONS = ["server", "serverRemotes", "ssrExternals", "target", "experiments"];
+export function resolveFederationOptions(options, renderer) {
+    assertPlainObject(options, "Federation options");
+    for (const field of SERVER_OPTIONS) {
+        if (field in options) {
+            throw new TypeError(`Federation option ${field} is not available in the client-only release. Follow server federation design in https://github.com/farming-labs/farm.js/issues/885`);
+        }
+    }
+    const name = nonEmptyString(options.name, "Federation name");
+    const exposes = normalizeExposes(options.exposes ?? {});
+    const remotes = normalizeRemotes(options.remotes ?? {});
+    const filename = normalizeOutputFile(options.filename ?? "remoteEntry.js");
+    const manifest = booleanOption(options.manifest, "manifest") ?? Object.keys(exposes).length > 0;
+    const types = booleanOption(options.types, "types") ?? true;
+    const shared = normalizeShared(options.shared, renderer);
+    const publicPath = optionalPublicPath(options.publicPath);
+    const remoteHmr = options.dev?.remoteHmr;
+    if (remoteHmr !== undefined && typeof remoteHmr !== "boolean" && remoteHmr !== "full-reload") {
+        throw new TypeError("Federation dev.remoteHmr must be true, false, or full-reload");
+    }
+    return {
+        remoteAliases: Object.keys(remotes),
+        upstream: {
+            name,
+            exposes,
+            remotes,
+            shared,
+            filename,
+            manifest,
+            dts: types
+                ? {
+                    generateTypes: { compileInChildProcess: false },
+                }
+                : false,
+            target: "web",
+            ...(publicPath ? { publicPath } : {}),
+            ...(remoteHmr === undefined ? {} : { dev: { remoteHmr } }),
+        },
+    };
+}
+function normalizeExposes(exposes) {
+    assertPlainObject(exposes, "Federation exposes");
+    return Object.fromEntries(Object.entries(exposes).map(([key, value]) => {
+        if (key !== "." && !key.startsWith("./")) {
+            throw new TypeError(`Federation expose ${JSON.stringify(key)} must be . or start with ./`);
+        }
+        if (typeof value === "string")
+            return [key, nonEmptyString(value, `Federation expose ${key}`)];
+        assertPlainObject(value, `Federation expose ${key}`);
+        return [key, { import: nonEmptyString(value.import, `Federation expose ${key} import`) }];
+    }));
+}
+function normalizeRemotes(remotes) {
+    assertPlainObject(remotes, "Federation remotes");
+    return Object.fromEntries(Object.entries(remotes).map(([alias, value]) => {
+        normalizeRemoteAlias(alias);
+        if (typeof value === "string") {
+            return [alias, normalizeRemoteString(value, alias)];
+        }
+        assertPlainObject(value, `Federation remote ${alias}`);
+        const entry = normalizeRemoteEntry(value.entry, alias);
+        const name = value.name === undefined ? alias : nonEmptyString(value.name, `Remote ${alias} name`);
+        return [
+            alias,
+            {
+                name,
+                entry,
+                type: value.type === undefined
+                    ? "module"
+                    : nonEmptyString(value.type, `Remote ${alias} type`),
+                ...(value.shareScope === undefined
+                    ? {}
+                    : { shareScope: normalizeShareScope(value.shareScope, alias) }),
+            },
+        ];
+    }));
+}
+function normalizeShared(shared, renderer) {
+    if (shared === false)
+        return {};
+    if (shared === undefined || shared === "renderer")
+        return rendererShares(renderer);
+    assertPlainObject(shared, "Federation shared");
+    const includeRenderer = booleanOption(shared.renderer, "shared.renderer") ?? true;
+    return {
+        ...(includeRenderer ? rendererShares(renderer) : {}),
+        ...packageShares(shared.packages ?? []),
+    };
+}
+function rendererShares(renderer) {
+    const roots = new Set((renderer.dedupe ?? []).map(packageRoot).filter(Boolean));
+    if (roots.size === 0) {
+        throw new TypeError(`Farm renderer ${JSON.stringify(renderer.name)} does not declare packages to share. Set shared to false or provide shared.packages explicitly.`);
+    }
+    const entries = [];
+    for (const root of roots) {
+        entries.push([root, { singleton: true }], [`${root}/`, { singleton: true }]);
+    }
+    return Object.fromEntries(entries);
+}
+function packageShares(shared) {
+    if (Array.isArray(shared)) {
+        return Object.fromEntries(shared.map((name) => [nonEmptyString(name, "Federation shared package"), {}]));
+    }
+    assertPlainObject(shared, "Federation shared packages");
+    return Object.fromEntries(Object.entries(shared).map(([name, value]) => {
+        const normalizedName = nonEmptyString(name, "Federation shared package name");
+        if (value === true)
+            return [normalizedName, {}];
+        assertPlainObject(value, `Federation shared package ${name}`);
+        return [normalizedName, { ...value }];
+    }));
+}
+function packageRoot(value) {
+    if (!value)
+        return "";
+    const segments = value.split("/");
+    return value.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+}
+function normalizeRemoteAlias(value) {
+    const alias = nonEmptyString(value, "Federation remote alias");
+    if (/\s|[?#\\]/.test(alias) || alias.startsWith("/") || alias.endsWith("/")) {
+        throw new TypeError(`Invalid federation remote alias: ${JSON.stringify(value)}`);
+    }
+    return alias;
+}
+function normalizeRemoteEntry(value, alias) {
+    const entry = nonEmptyString(value, `Federation remote ${alias} entry`);
+    if (entry.startsWith("/")) {
+        if (entry.startsWith("//") || entry.includes("\\")) {
+            throw new TypeError(`Federation remote ${alias} entry must be a root-relative URL, not a network-path URL`);
+        }
+        return entry;
+    }
+    if (entry.includes("\\")) {
+        throw new TypeError(`Federation remote ${alias} entry must use URL separators`);
+    }
+    let parsed;
+    try {
+        parsed = new URL(entry);
+    }
+    catch {
+        throw new TypeError(`Federation remote ${alias} entry must be an HTTP URL or root-relative URL`);
+    }
+    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+        parsed.username ||
+        parsed.password) {
+        throw new TypeError(`Federation remote ${alias} entry must use HTTP without URL credentials`);
+    }
+    return parsed.href;
+}
+function normalizeRemoteString(value, alias) {
+    const remote = nonEmptyString(value, `Federation remote ${alias}`);
+    if (/^(?:https?:)?\//i.test(remote))
+        return normalizeRemoteEntry(remote, alias);
+    const separator = remote.indexOf("@");
+    if (separator <= 0 || separator === remote.length - 1) {
+        throw new TypeError(`Federation remote ${alias} must be an HTTP URL, root-relative URL, or name@URL`);
+    }
+    const name = remote.slice(0, separator);
+    if (/\s|[/?#\\]/.test(name) || hasControlCharacter(name)) {
+        throw new TypeError(`Federation remote ${alias} has an invalid remote name`);
+    }
+    return `${name}@${normalizeRemoteEntry(remote.slice(separator + 1), alias)}`;
+}
+function normalizeShareScope(value, alias) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            throw new TypeError(`Remote ${alias} shareScope cannot be empty`);
+        return value.map((scope) => nonEmptyString(scope, `Remote ${alias} shareScope`));
+    }
+    return nonEmptyString(value, `Remote ${alias} shareScope`);
+}
+function normalizeOutputFile(value) {
+    const filename = nonEmptyString(value, "Federation filename").replace(/^\/+/, "");
+    const segments = filename.split("/");
+    if (value.includes("\\") ||
+        value.includes("?") ||
+        value.includes("#") ||
+        segments.some((segment) => !segment || segment === "." || segment === "..") ||
+        !/\.m?js$/i.test(filename)) {
+        throw new TypeError("Federation filename must be a safe relative .js or .mjs path");
+    }
+    return filename;
+}
+function optionalPublicPath(value) {
+    if (value === undefined)
+        return undefined;
+    const publicPath = nonEmptyString(value, "Federation publicPath");
+    if (publicPath === "auto")
+        return publicPath;
+    if (publicPath.startsWith("/")) {
+        if (publicPath.startsWith("//") || publicPath.includes("\\")) {
+            throw new TypeError("Federation publicPath must be a root-relative URL, not a network-path URL");
+        }
+        return publicPath;
+    }
+    if (publicPath.includes("\\")) {
+        throw new TypeError("Federation publicPath must use URL separators");
+    }
+    let parsed;
+    try {
+        parsed = new URL(publicPath);
+    }
+    catch {
+        throw new TypeError("Federation publicPath must be auto, root-relative, or an HTTP URL");
+    }
+    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+        parsed.username ||
+        parsed.password) {
+        throw new TypeError("Federation publicPath must use HTTP without URL credentials");
+    }
+    return parsed.href;
+}
+function booleanOption(value, label) {
+    if (value !== undefined && typeof value !== "boolean") {
+        throw new TypeError(`Federation ${label} must be a boolean`);
+    }
+    return value;
+}
+function nonEmptyString(value, label) {
+    if (typeof value !== "string" || !value.trim() || hasControlCharacter(value)) {
+        throw new TypeError(`${label} must be a non-empty string without control characters`);
+    }
+    return value.trim();
+}
+function hasControlCharacter(value) {
+    return Array.from(value).some((character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint <= 0x1f || codePoint === 0x7f;
+    });
+}
+function assertPlainObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError(`${label} must be an object`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { type FederationOptions, type FederationRemote, type FederationSharedOptions, type FederationSharedPackage, type FederationSharedPackages } from "./config.js";
+export type { FederationOptions, FederationRemote, FederationSharedOptions, FederationSharedPackage, FederationSharedPackages, };
+/** Publish and consume independently deployed browser modules from a Farm application. */
+export declare function federation(options: FederationOptions): import("@farm.js/core/plugin").FarmPlugin<undefined, Record<string, never>, unknown, undefined, unknown, false>;
+//# 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":"AACA,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC9B,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,wBAAwB,GACzB,CAAC;AAEF,0FAA0F;AAC1F,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,mHAyBpD"}

package/dist/index.js

@@ -0,0 +1,26 @@
+import { definePlugin } from "@farm.js/core/plugin";
+import { resolveFederationOptions, } from "./config.js";
+import { createFarmFederationVitePlugins } from "./vite.js";
+/** Publish and consume independently deployed browser modules from a Farm application. */
+export function federation(options) {
+    return definePlugin({
+        name: "farm:federation",
+        enforce: "post",
+        configure(config) {
+            if ((config.plugins ?? []).filter((candidate) => candidate.name === "farm:federation").length >
+                1) {
+                throw new Error("[farm:federation] Configure federation in one federation() instance");
+            }
+            const renderer = config.renderer ?? { name: "react", dedupe: ["react", "react-dom"] };
+            const resolved = resolveFederationOptions(options, renderer);
+            const vite = config.vite ?? {};
+            return {
+                ...config,
+                vite: {
+                    ...vite,
+                    plugins: [...(vite.plugins ?? []), ...createFarmFederationVitePlugins(resolved)],
+                },
+            };
+        },
+    });
+}

package/dist/vite.d.ts

@@ -0,0 +1,35 @@
+import type { ResolvedFederationOptions } from "./config.js";
+interface ViteConfigLike {
+    build?: {
+        ssr?: unknown;
+        rollupOptions?: {
+            output?: FederationOutputOptions | FederationOutputOptions[];
+        };
+        rolldownOptions?: {
+            output?: FederationOutputOptions | FederationOutputOptions[];
+        };
+    };
+}
+interface FederationOutputOptions {
+    codeSplitting?: {
+        groups?: Array<Record<string, unknown>>;
+    };
+    [key: string]: unknown;
+}
+interface ViteEnvironmentLike {
+    command: string;
+}
+interface VitePluginLike {
+    name?: string;
+    apply?: string | ((config: ViteConfigLike, environment: ViteEnvironmentLike) => boolean | undefined);
+    resolveId?: unknown;
+    load?: unknown;
+    transform?: unknown;
+    [key: string]: unknown;
+}
+type VitePluginOption = VitePluginLike | false | null | undefined | Promise<VitePluginOption> | VitePluginOption[];
+export declare function createFarmFederationVitePlugins(options: ResolvedFederationOptions, factory?: (options: ResolvedFederationOptions["upstream"]) => VitePluginOption[]): VitePluginOption[];
+export declare function restrictPluginOptionToClient(option: VitePluginOption): VitePluginOption;
+export declare function restrictPluginToClient(plugin: VitePluginLike): VitePluginLike;
+export {};
+//# sourceMappingURL=vite.d.ts.map

package/dist/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../src/vite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D,UAAU,cAAc;IACtB,KAAK,CAAC,EAAE;QACN,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,aAAa,CAAC,EAAE;YACd,MAAM,CAAC,EAAE,uBAAuB,GAAG,uBAAuB,EAAE,CAAC;SAC9D,CAAC;QACF,eAAe,CAAC,EAAE;YAChB,MAAM,CAAC,EAAE,uBAAuB,GAAG,uBAAuB,EAAE,CAAC;SAC9D,CAAC;KACH,CAAC;CACH;AAED,UAAU,uBAAuB;IAC/B,aAAa,CAAC,EAAE;QACd,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;KACzC,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,UAAU,mBAAmB;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,cAAc;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EACF,MAAM,GACN,CAAC,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,mBAAmB,KAAK,OAAO,GAAG,SAAS,CAAC,CAAC;IACxF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,KAAK,gBAAgB,GACjB,cAAc,GACd,KAAK,GACL,IAAI,GACJ,SAAS,GACT,OAAO,CAAC,gBAAgB,CAAC,GACzB,gBAAgB,EAAE,CAAC;AAMvB,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,yBAAyB,EAClC,OAAO,GAAE,CAAC,OAAO,EAAE,yBAAyB,CAAC,UAAU,CAAC,KAAK,gBAAgB,EAAmB,GAC/F,gBAAgB,EAAE,CAQpB;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CASvF;AA4BD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,cAAc,GAAG,cAAc,CAoB7E"}

package/dist/vite.js

@@ -0,0 +1,173 @@
+import { federation as viteFederation } from "@module-federation/vite";
+const SERVER_RUNTIME_ID = "\0farm:federation:server-runtime";
+export function createFarmFederationVitePlugins(options, factory = viteFederation) {
+    const upstream = factory(options.upstream).map(restrictPluginOptionToClient);
+    return [
+        serverImportGuard(options.remoteAliases),
+        isolateFarmExposes(),
+        ...upstream,
+        repairFarmManifest(),
+    ];
+}
+export function restrictPluginOptionToClient(option) {
+    if (option instanceof Promise) {
+        return option.then(restrictPluginOptionToClient);
+    }
+    if (Array.isArray(option)) {
+        return option.map(restrictPluginOptionToClient);
+    }
+    if (!option || typeof option !== "object")
+        return option;
+    return restrictPluginToClient(option);
+}
+function isolateFarmExposes() {
+    return {
+        name: "farm:federation:output-boundary",
+        apply: "build",
+        enforce: "post",
+        config(config) {
+            if (config.build?.ssr)
+                return;
+            for (const output of [
+                config.build?.rollupOptions?.output,
+                config.build?.rolldownOptions?.output,
+            ]) {
+                for (const candidate of Array.isArray(output) ? output : output ? [output] : []) {
+                    const codeSplitting = (candidate.codeSplitting ??= {});
+                    const groups = (codeSplitting.groups ??= []);
+                    if (groups.some((group) => group.name === "federation-exposes"))
+                        continue;
+                    groups.push({
+                        name: "federation-exposes",
+                        test: /virtual:mf-exposes:/,
+                        priority: 999_999,
+                    });
+                }
+            }
+        },
+    };
+}
+export function restrictPluginToClient(plugin) {
+    const originalApply = plugin.apply;
+    const wrapped = {
+        ...plugin,
+        apply(config, environment) {
+            if (config.build?.ssr)
+                return false;
+            // Farm uses a short-lived Vite serve environment for production route discovery.
+            // Treat it as part of the build so upstream development workers do not outlive the CLI.
+            if (environment.command === "serve" && process.env.NODE_ENV === "production")
+                return false;
+            if (typeof originalApply === "function") {
+                return originalApply.call(this, config, environment);
+            }
+            return originalApply === undefined || originalApply === environment.command;
+        },
+    };
+    wrapped.resolveId = wrapEnvironmentHook(plugin.resolveId, 2);
+    wrapped.load = wrapEnvironmentHook(plugin.load, 1);
+    wrapped.transform = wrapEnvironmentHook(plugin.transform, 2);
+    return wrapped;
+}
+function serverImportGuard(remoteAliases) {
+    return {
+        name: "farm:federation:server-import-guard",
+        enforce: "pre",
+        resolveId(id, _importer, options) {
+            if (!isServerEnvironment(this, options))
+                return null;
+            if (id === "@module-federation/runtime")
+                return SERVER_RUNTIME_ID;
+            if (!matchesRemote(id, remoteAliases))
+                return null;
+            const message = `[farm:federation] Remote module ${JSON.stringify(id)} entered Farm's server graph. ` +
+                "The current release federates browser modules only. Load it after hydration with " +
+                "@farm.js/federation/client. Server federation is tracked at " +
+                "https://github.com/farming-labs/farm.js/issues/885";
+            if (this.error)
+                return this.error(message);
+            throw new Error(message);
+        },
+        load(id) {
+            if (id !== SERVER_RUNTIME_ID)
+                return null;
+            return `
+const serverError = () => {
+  throw new Error("[farm:federation] Remote browser modules must be loaded after hydration with @farm.js/federation/client.");
+};
+export const loadRemote = serverError;
+export const preloadRemote = serverError;
+`;
+        },
+    };
+}
+function repairFarmManifest() {
+    return {
+        name: "farm:federation:manifest",
+        apply: "build",
+        enforce: "post",
+        generateBundle(_output, bundle) {
+            const remoteEntry = Object.values(bundle).find((output) => {
+                if (!output || typeof output !== "object")
+                    return false;
+                const chunk = output;
+                return (chunk.type === "chunk" &&
+                    typeof chunk.facadeModuleId === "string" &&
+                    chunk.facadeModuleId.includes("mf-REMOTE_ENTRY_ID"));
+            });
+            if (!remoteEntry || typeof remoteEntry.fileName !== "string")
+                return;
+            for (const output of Object.values(bundle)) {
+                if (!output || typeof output !== "object")
+                    continue;
+                const asset = output;
+                if (asset.type !== "asset" ||
+                    typeof asset.fileName !== "string" ||
+                    !/(?:^|\/)(?:mf-manifest|mf-stats)\.json$/.test(asset.fileName)) {
+                    continue;
+                }
+                const source = typeof asset.source === "string" ? asset.source : asset.source?.toString();
+                if (!source)
+                    continue;
+                const document = JSON.parse(source);
+                if (!document.metaData?.remoteEntry || document.metaData.remoteEntry.name)
+                    continue;
+                document.metaData.remoteEntry.name = remoteEntry.fileName;
+                asset.source = JSON.stringify(document);
+            }
+        },
+    };
+}
+function wrapEnvironmentHook(hook, optionsIndex) {
+    if (typeof hook === "function") {
+        return function (...args) {
+            if (isServerEnvironment(this, args[optionsIndex]))
+                return null;
+            return hook.apply(this, args);
+        };
+    }
+    if (hook &&
+        typeof hook === "object" &&
+        typeof hook.handler === "function") {
+        const hookObject = hook;
+        return {
+            ...hookObject,
+            handler(...args) {
+                if (isServerEnvironment(this, args[optionsIndex]))
+                    return null;
+                return hookObject.handler.apply(this, args);
+            },
+        };
+    }
+    return hook;
+}
+function isServerEnvironment(context, options) {
+    const environmentName = context?.environment?.name;
+    return (environmentName === "rsc" ||
+        environmentName === "ssr" ||
+        environmentName === "server" ||
+        Boolean(options?.ssr));
+}
+function matchesRemote(id, aliases) {
+    return (typeof id === "string" && aliases.some((alias) => id === alias || id.startsWith(`${alias}/`)));
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@farm.js/federation",
+  "version": "0.1.0-beta.0",
+  "description": "Client-side Module Federation for Farm.js applications",
+  "keywords": [
+    "farm.js",
+    "micro-frontends",
+    "module-federation",
+    "vite"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/farming-labs/farm.js",
+    "directory": "packages/farm-federation"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@module-federation/runtime": "^2.9.0",
+    "@module-federation/vite": "^1.21.6",
+    "@farm.js/core": "0.1.0-beta.92"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.5",
+    "typescript": "^5.3.3",
+    "vitest": "^3.2.7"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc",
+    "dev": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}