@appshell/webpack-plugin 1.0.0-alpha.9 → 1.0.0-alpha.91

package/dist/types/config/src/utils/index.d.ts

@@ -2,9 +2,6 @@ export { default as blur } from './blur';
 export { compareDependencies, compareDependency, compareSharedDependencies, compareSharedModules, extractDependencies, printResults, } from './compare';
 export { mergeConfigWithArgs, readConfig, writeConfig } from './config';
 export { default as copy } from './copy';
-export { default as isValidUrl } from './isValidUrl';
+export { default as dump } from './dump';
 export { default as list } from './list';
 export { default as load, loadAll } from './load';
-export { default as loadJson } from './loadJson';
-export { default as merge } from './merge';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/config/src/utils/list.d.ts

@@ -7,4 +7,3 @@
  */
 declare const list: (dirPath: string, depth?: number, target?: string | RegExp) => string[];
 export default list;
-//# sourceMappingURL=list.d.ts.map

package/dist/types/config/src/utils/load.d.ts

@@ -11,4 +11,3 @@ declare const load: <TSchema>(configPath: string) => TSchema;
  */
 export declare const loadAll: <TSchema>(...paths: string[]) => TSchema[];
 export default load;
-//# sourceMappingURL=load.d.ts.map

package/dist/types/config/src/validators/AppshellTemplateValidator.d.ts

@@ -1,4 +1,3 @@
 import { ConfigValidator } from '../types';
 declare const _default: ConfigValidator;
 export default _default;
-//# sourceMappingURL=AppshellTemplateValidator.d.ts.map

package/dist/types/config/src/validators/index.d.ts

@@ -1,4 +1 @@
-export { default as AppshellGlobalConfigValidator } from './AppshellGlobalConfigValidator';
-export { default as AppshellManifestValidator } from './AppshellManifestValidator';
 export { default as AppshellTemplateValidator } from './AppshellTemplateValidator';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/runtime/src/errors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * A package asked for vars that were never delivered.
+ *
+ * Almost always one of three things: the package was loaded outside `remoteLoader`
+ * (a test, a storybook, a direct import), the host and the package resolved separate
+ * copies of `@appshell/runtime` because one of them failed to declare it as a
+ * singleton, or the scope compiled into the package is not the scope the registry
+ * knows it by.
+ */
+export declare class MissingVarsError extends Error {
+    readonly scope: string;
+    constructor(scope: string, known: string[]);
+}
+/**
+ * Something tried to replace vars that were already delivered for a scope.
+ *
+ * The first write wins and is final. Within one page load a scope has exactly one
+ * vars object — both resolvers read it from the same `composition.vars[scope]` — so a
+ * differing second write is a bug or a package reaching for a scope that is not its own,
+ * and neither should be applied quietly.
+ */
+export declare class VarsConflictError extends Error {
+    readonly scope: string;
+    constructor(scope: string);
+}
+/**
+ * The package was built without `AppshellPlugin`, so nothing substituted the scope the
+ * `@appshell/runtime/vars` accessor needs to know which vars are its own.
+ */
+export declare class MissingScopeError extends Error {
+    constructor();
+}

package/dist/types/runtime/src/identity.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Who is looking at the page, as the registry was told by the gateway.
+ *
+ * Unlike vars this is not scope-specific — there is one visitor per page, not one
+ * per package — so it lives in the main entry rather than needing the subpath
+ * trick `@appshell/runtime/vars` uses to get a per-package scope substituted.
+ *
+ * It is also not delivered through the vars store, and that is a constraint rather
+ * than a preference: `setVars` freezes on first write and throws on replacement,
+ * which is what stops one package overwriting another's configuration. Identity
+ * changes — sign-in, sign-out, token refresh — so it cannot live behind a
+ * write-once door without either breaking that guarantee or never updating.
+ */
+/**
+ * A discriminated union rather than an optional user, so `username` cannot be read
+ * without the anonymous case having been handled. The compiler enforces what a
+ * convention would only ask for.
+ */
+export type Identity = {
+    authenticated: false;
+} | {
+    authenticated: true;
+    subject: string;
+    username: string;
+    roles: string[];
+};
+export declare const ANONYMOUS: Identity;
+declare global {
+    interface Window {
+        __appshell_identity__?: unknown;
+    }
+}
+/**
+ * The visitor, or the anonymous identity when there is none.
+ *
+ * Never throws and never returns undefined — an absent or malformed value is
+ * anonymous, which is a state every caller already has to handle. That is the
+ * opposite of `readVars`, which throws when a scope is missing, and the difference
+ * is deliberate: a package with no configuration cannot do its job, while a package
+ * with no signed-in user usually can and simply renders differently.
+ *
+ * This is a typed accessor, not a boundary. The value is inlined into the document
+ * and any script on the page can read it directly, exactly as with vars. Treat it
+ * as what the server said about the visitor, never as proof of anything: it carries
+ * no token and grants nothing. Anything that matters is re-checked server-side.
+ */
+export declare const getIdentity: () => Identity;

package/dist/types/runtime/src/index.d.ts

@@ -0,0 +1,6 @@
+export { MissingScopeError, MissingVarsError, VarsConflictError } from './errors';
+export { ANONYMOUS, getIdentity } from './identity';
+export type { Identity } from './identity';
+export { hasVars, readVars, resetVars, setVars } from './store';
+export type { Vars } from './types';
+export type { AppshellIndex, AppshellRemote, Metadata, ModuleFederationLoader, RemoteLoader, } from './wire';

package/dist/types/runtime/src/store.d.ts

@@ -0,0 +1,25 @@
+import type { Vars } from './types';
+/**
+ * Delivers a scope's vars. Called by `@appshell/loader` immediately before the remote
+ * is loaded, so they are in place before the package's modules evaluate.
+ *
+ * The first write for a scope wins and is frozen. Re-delivering the identical vars is a
+ * no-op — the same remote can be mounted more than once — but replacing them throws.
+ * That is what keeps one package from overwriting another's: by the time any package
+ * evaluates, the host has already written for it.
+ *
+ * It does not make a scope's vars *private*. Any code on the page can still read another
+ * scope by name, and nothing short of a separate realm would change that.
+ */
+export declare const setVars: (scope: string, vars: Vars) => void;
+/**
+ * Reads a scope's vars, throwing rather than handing back an empty object — a package
+ * that silently renders with no configuration is the failure this replaced.
+ *
+ * Prefer `getVars()` from `@appshell/runtime/vars`, which supplies the scope for you.
+ */
+export declare const readVars: <TVars extends Vars = Vars>(scope: string) => TVars;
+/** Whether a scope has been delivered, for callers that want to branch instead of catch. */
+export declare const hasVars: (scope: string) => boolean;
+/** Test seam. Not part of the contract a package should build on. */
+export declare const resetVars: () => void;

package/dist/types/runtime/src/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A package's runtime configuration, already merged by the registry — a package's
+ * declared vars, then the application's `overrides.vars`.
+ *
+ * Structurally identical to `AppshellComposition['vars'][scope]` in `@appshell/config`,
+ * but declared here rather than imported. This package is a shared singleton loaded
+ * into every micro-frontend on the page, so it carries no dependencies at all.
+ */
+export type Vars = Record<string, string | number | undefined>;

package/dist/types/runtime/src/wire.d.ts

@@ -0,0 +1,58 @@
+/**
+ * What the browser is told about a remote.
+ *
+ * These live here rather than in `@appshell/config` because config is build tooling — it
+ * carries yaml, lodash and axios — and a package that only wants to type a remote should
+ * not install a compiler to get it. This package is already the one every micro-frontend
+ * on the page shares, and it has no dependencies of its own to pass on.
+ *
+ * `AppshellManifest` deliberately stays in `@appshell/config`. It is a build artifact, and
+ * its `modules` field is Module Federation plugin options — build-time webpack
+ * configuration the browser never sees and this package should never drag in.
+ */
+/** Arbitrary, application-defined description of a remote. Appshell never reads it. */
+export type Metadata = Record<string, unknown>;
+/**
+ * How a host loads a remote, named as one kind among possible kinds.
+ *
+ * scope, module and shareScope are Module Federation's vocabulary, and they used to sit
+ * at the top level of a remote where nothing said so — which is what would have made a
+ * second framework awkward, not the words themselves. Nested under a kind they are
+ * exactly correct, and something like single-spa slots beside them without reinterpreting
+ * anything already published.
+ *
+ * apiVersion follows the house style set by appshell.app.yaml, and the group is appshell's
+ * because appshell owns this schema: it decides which fields it stores, even though the
+ * fields describe federation concepts. If federation ever needs a different recipe that is
+ * a v2, and manifests published under v1 keep meaning what they meant — which matters,
+ * because they are immutable and hashed.
+ */
+export type ModuleFederationLoader = {
+    apiVersion: 'federation.appshell.org/v1';
+    kind: 'ModuleFederation';
+    scope: string;
+    module: string;
+    shareScope?: string;
+    /** The entry file the build emits, conventionally remoteEntry.js. */
+    filename: string;
+    /**
+     * What built this, recorded as a fact rather than a constraint.
+     *
+     * Deliberately not a version range. A range is a claim about the environment, and a
+     * package cannot make it: it knows what built it and not what will load it, and the
+     * host is what registers the remote. Freezing one into an immutable artifact is the
+     * same mistake as freezing its origin.
+     */
+    builtWith?: string;
+};
+export type RemoteLoader = ModuleFederationLoader;
+/** A remote the registry has already resolved, so the browser needs no manifest fetch. */
+export type AppshellRemote<TMetadata = Metadata> = {
+    id: string;
+    manifestUrl: string;
+    remoteEntryUrl: string;
+    loader: RemoteLoader;
+    metadata: TMetadata;
+};
+/** Remote key to manifest url. */
+export type AppshellIndex = Record<string, string>;

package/dist/types/tokens/src/contract.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The token contract: the complete, fixed vocabulary a package may consume and an
+ * Application must supply.
+ *
+ * Small and stable is the property that matters. A package authors against these names
+ * with fallbacks (`var(--appshell-primary, #0af)`) and renders standalone; an Application
+ * supplies the values and every package it composes moves together.
+ */
+export type Mode = 'light' | 'dark';
+/** Colour roles an Application's *base* supplies — everything not tied to the accent. */
+export declare const BASE_COLOR_ROLES: readonly ["surface", "on-surface", "surface-raised", "on-surface-raised", "text-muted", "border", "danger", "on-danger", "warning", "on-warning", "success", "on-success"];
+/** Colour roles an Application's *accent* supplies. */
+export declare const ACCENT_COLOR_ROLES: readonly ["primary", "on-primary", "secondary", "on-secondary"];
+/**
+ * Derived rather than authored. Hover and active are computed from their accent with
+ * `color-mix`, and the focus ring is picked per base+accent so it stays visible. A theme
+ * may override any of them; none has to be supplied.
+ */
+export declare const DERIVED_COLOR_ROLES: readonly ["primary-hover", "primary-active", "secondary-hover", "secondary-active", "focus-ring"];
+/**
+ * Named for their role, not their size. A numeric scale would reintroduce exactly the
+ * divergence this contract exists to prevent — one author mapping `h1` to `2xl` and
+ * another to `xl` is how headings stop matching across a composed page.
+ */
+export declare const TYPE_ROLES: readonly ["font-body", "font-mono", "font-size-h1", "font-size-h2", "font-size-h3", "font-size-h4", "font-size-h5", "font-size-h6", "font-size-body", "font-size-small", "line-height-tight", "line-height-normal"];
+/** Genuinely a scale. Nobody wants `--appshell-space-card-padding`. */
+export declare const DIMENSION_ROLES: readonly ["space-xs", "space-sm", "space-md", "space-lg", "space-xl", "radius-sm", "radius-md", "radius-lg"];
+export type BaseColorRole = (typeof BASE_COLOR_ROLES)[number];
+export type AccentColorRole = (typeof ACCENT_COLOR_ROLES)[number];
+export type DerivedColorRole = (typeof DERIVED_COLOR_ROLES)[number];
+export type TypeRole = (typeof TYPE_ROLES)[number];
+export type DimensionRole = (typeof DIMENSION_ROLES)[number];
+export type TokenRole = BaseColorRole | AccentColorRole | DerivedColorRole | TypeRole | DimensionRole;
+export declare const TOKEN_ROLES: readonly TokenRole[];
+export type BaseTokens = Record<BaseColorRole, string>;
+export type AccentTokens = Record<AccentColorRole, string>;
+export type Theme = Record<TokenRole, string>;
+/** The custom property a role is published as. */
+export declare const cssVar: (role: TokenRole) => string;
+/**
+ * Pairs the registry checks for contrast. Because every role that carries text has an
+ * `on-` partner, a theme cannot express illegible text without failing this list — which
+ * is the failure that actually reaches users, and the one a CSS parser alone never catches.
+ */
+export declare const TEXT_PAIRS: readonly (readonly [TokenRole, TokenRole])[];
+/** Muted text has no `on-` partner; it is read against both surfaces. */
+export declare const MUTED_AGAINST: readonly TokenRole[];
+/** Non-text, so 3:1 rather than 4.5:1 — WCAG 1.4.11. */
+export declare const NON_TEXT_PAIRS: readonly (readonly [TokenRole, TokenRole])[];
+export declare const AA_TEXT = 4.5;
+export declare const AA_NON_TEXT = 3;

package/dist/types/tokens/src/contrast.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Contrast checking for a theme.
+ *
+ * Syntax validation on its own earns little: it catches `--appshell-primary: bananas` and
+ * misses `--appshell-on-primary: #fff` on `--appshell-primary: #fff`, which is valid CSS
+ * and invisible text. Checking the `on-` pairs catches the failure that reaches users, and
+ * subsumes syntax validation for free — a value that will not parse cannot be measured.
+ */
+import { type Theme, type TokenRole } from './contract';
+type Rgb = [number, number, number];
+/** Returns undefined rather than throwing — an unmeasurable value is reported, not fatal. */
+export declare const parseColor: (value: string) => Rgb | undefined;
+/** WCAG 2.1 contrast ratio, 1–21. */
+export declare const contrastRatio: (a: Rgb, b: Rgb) => number;
+/**
+ * A colour as `#rrggbb`.
+ *
+ * `<meta name="theme-color">` takes a CSS colour, but browser support for `oklch` there
+ * is not something to rely on for a hint the page cannot detect the failure of — a
+ * value the browser does not understand is simply ignored, silently.
+ */
+export declare const toHex: (value: string) => string | undefined;
+export type ContrastFinding = {
+    roles: [TokenRole, TokenRole];
+    ratio?: number;
+    required: number;
+    reason: 'below-threshold' | 'unparseable';
+};
+/**
+ * Every finding for a theme. Empty means it passes.
+ *
+ * `color-mix` values are skipped rather than failed: hover and active are derived from
+ * roles that are themselves checked, and resolving them needs a browser.
+ */
+export declare const validateTheme: (theme: Theme) => ContrastFinding[];
+export declare const describeFinding: ({ roles, ratio, required, reason }: ContrastFinding) => string;
+export {};

package/dist/types/tokens/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './contract';
+export { contrastRatio, describeFinding, parseColor, toHex, validateTheme, type ContrastFinding, } from './contrast';
+export { ACCENTS, BASES, FOCUS_RINGS } from './presets';
+export { DEFAULT_TYPE_AND_DIMENSIONS, composeTheme, cssFrom, pinnedMode, resolveTheme, toCss, type ColorScheme, type CssOptions, type ResolvedTheme, type ThemeSelection, } from './theme';

package/dist/types/tokens/src/presets.d.ts

@@ -0,0 +1,4 @@
+import type { AccentTokens, BaseTokens, Mode } from './contract';
+export declare const BASES: Record<string, Record<Mode, BaseTokens>>;
+export declare const ACCENTS: Record<string, AccentTokens>;
+export declare const FOCUS_RINGS: Record<string, Record<string, Record<Mode, string>>>;

package/dist/types/tokens/src/theme.d.ts

@@ -0,0 +1,54 @@
+import { type AccentTokens, type BaseTokens, type Mode, type Theme } from './contract';
+/**
+ * `system` follows the viewer's preference. Pinning a scheme is for an application that
+ * ships one look on purpose, and it is honoured all the way down: the palette stops
+ * varying, the root is stamped so the tokens cannot be swapped underneath it, and the
+ * browser is told which scheme to render its own scrollbars and form controls in.
+ */
+export type ColorScheme = 'system' | 'light' | 'dark';
+export type ThemeSelection = {
+    /** A base preset name, or the base's own token values. */
+    base: string | Record<Mode, BaseTokens>;
+    /** An accent preset name, or the accent's own token values. */
+    accent: string | AccentTokens;
+    /** Defaults to `system`. */
+    colorScheme?: ColorScheme;
+    /** Overrides applied last, so an Application can adjust a preset without forking it. */
+    overrides?: Partial<Theme>;
+};
+/** The mode a pinned scheme resolves to, or undefined when it follows the viewer. */
+export declare const pinnedMode: (selection: ThemeSelection) => Mode | undefined;
+/** Type and dimensions do not vary by mode, and no preset currently changes them. */
+export declare const DEFAULT_TYPE_AND_DIMENSIONS: Record<string, string>;
+/** The full token map for one mode. */
+export declare const composeTheme: (selection: ThemeSelection, mode: Mode) => Theme;
+/**
+ * A theme with both modes already worked out.
+ *
+ * This is the shape a *published* theme stores. Resolving a selection and emitting CSS
+ * used to be one step, which meant the only way to render a theme was to re-resolve its
+ * preset names — so the values behind a name lived in whatever build was deployed, and an
+ * Application's recorded appearance moved when that build did. Materialising both modes
+ * lets the values be stored, versioned and rendered from, rather than looked up.
+ */
+export type ResolvedTheme = Record<Mode, Theme>;
+/** Works out both modes of a selection, including any overrides it carries. */
+export declare const resolveTheme: (selection: ThemeSelection) => ResolvedTheme;
+export type CssOptions = {
+    /** Defaults to `system`. Belongs to whoever is rendering, not to the theme. */
+    colorScheme?: ColorScheme;
+    /** Applied over the resolved values, so a consumer can adjust without forking. */
+    overrides?: Partial<Theme>;
+};
+/**
+ * Three states, not two: an explicit choice in either direction, and the system default
+ * when nothing is stamped on the root. A theme that only handled `prefers-color-scheme`
+ * would give a viewer no way to override it.
+ */
+export declare const cssFrom: (resolved: ResolvedTheme, options?: CssOptions) => string;
+/**
+ * Resolve and emit in one step. The authoring path — a preset name in hand, CSS wanted.
+ * The registry uses `cssFrom` against a stored theme instead, so what it renders cannot
+ * drift from what was published.
+ */
+export declare const toCss: (selection: ThemeSelection) => string;

package/dist/types/webpack-plugin/src/AppshellPlugin.d.ts

@@ -3,7 +3,7 @@ import { Compiler, WebpackOptionsNormalized, WebpackPluginInstance } from 'webpa
 type AppshellPluginOptions = {
     config?: string;
     registry?: string;
-    environment?: string;
+    application?: string;
     publish?: boolean;
     force?: boolean;
 };
@@ -24,14 +24,56 @@ export default class AppshellPlugin {
     static findModuleFederationPlugin(webpackConfig: WebpackOptionsNormalized): ModuleFederationPluginInstance | undefined;
     static createTemplate(config: AppshellConfig, plugin: ModuleFederationPluginInstance): AppshellTemplate;
     static validate(template: AppshellTemplate): boolean;
+    /**
+     * Which tokens this package's output actually reaches for.
+     *
+     * Read from the emitted assets rather than declared. The CSS already states it, and a
+     * hand-kept list is a second copy that goes stale the first time somebody adds a token
+     * and forgets to update it. This cannot drift, because it *is* the usage.
+     *
+     * A role referenced both with and without a fallback counts as required: one place in
+     * the package has nothing to fall back to.
+     *
+     * The blind spot is a reference built at runtime from a constructed string, which no
+     * static scan sees — the same limit Tailwind has with dynamic class names. It fails
+     * toward under-reporting, never toward inventing a requirement.
+     *
+     * Takes file contents rather than webpack assets: by `afterEmit` the compilation has
+     * swapped its sources for `SizeOnlySource`, which knows a length and nothing else.
+     * The files are on disk by then, which is what the hook means.
+     */
+    static tokenUsage(sources?: Record<string, string>): {
+        required: string[];
+        optional: string[];
+        unknown: string[];
+    };
+    /**
+     * Whether a request is shared, and shared as a singleton. `shared` has four shapes —
+     * an object, an array of names, an array of objects, or a mix — and a bare name shares
+     * without making it a singleton, which for the vars store is the same as not sharing it.
+     */
+    static sharedSingleton(shared: ModuleFederationPluginOptions['shared'], request: string): {
+        declared: boolean;
+        singleton: boolean;
+    };
     /**
      * Publish identity is the npm identity of the package being built, not the module
      * federation name — the registry requires a lowercase name and has no other source
      * for a version. The scope is taken from the caller's token, so it is stripped here.
      */
+    /**
+     * Points this package's remotes at the running dev server, for this developer only.
+     *
+     * Deliberately incapable of failing a build. A dev server that will not start because a
+     * registry is unreachable, a token expired, or a package was never published is worse
+     * than one serving code the browser cannot yet compose — the developer can still see
+     * their own output, and the message says what to do about the rest.
+     */
+    private static redirectToDevServer;
     static identify(context: string): {
-        name: string;
         version: string;
+        scopeId?: string;
+        name: string;
     };
     /**
      * Warns when an env var or explicit option points somewhere other than the
@@ -39,10 +81,10 @@ export default class AppshellPlugin {
      */
     static overrideNotices(effective: {
         registry?: string;
-        environment?: string;
+        application?: string;
     }, persisted: {
         registry?: string;
-        environment?: string;
+        application?: string;
     }): string[];
     /**
      * Apply the plugin
@@ -52,4 +94,3 @@ export default class AppshellPlugin {
     apply(compiler: Compiler): void;
 }
 export {};
-//# sourceMappingURL=AppshellPlugin.d.ts.map

package/dist/types/webpack-plugin/src/devHint.d.ts

@@ -0,0 +1,45 @@
+export declare const DEV_HINT_FILE = ".appshell-dev.json";
+export declare const DEV_HINT_VERSION = 1;
+export type DevHint = {
+    version: number;
+    /** Where this package's dev server is reachable, as a browser on this machine would ask. */
+    origin: string;
+    /** From the federation `filename`, so a reader can probe without asking the registry. */
+    remoteEntryPath: string;
+    /**
+     * Diagnostics only. Deliberately not a liveness signal: a server running happily for
+     * hours writes an old timestamp, and one that crashed a second ago writes a fresh one.
+     * Whether the origin is live is answered by asking the origin.
+     */
+    writtenAt: string;
+};
+type DevServerOptions = {
+    [index: string]: unknown;
+} | false | undefined;
+/**
+ * Whether this dev server's hot-reload client has an address a browser can actually dial.
+ *
+ * webpack-dev-server normalizes `client.webSocketURL` into an object before a plugin ever
+ * sees it, filling the hostname from whatever the server **bound**. So a server listening
+ * on every interface hands its client `0.0.0.0`, which nothing can open a socket to, and
+ * asking whether the option is *set* cannot tell that apart from a deliberate choice —
+ * it is always set. The dialable address is the property that matters, so that is what is
+ * checked, against the same host list `devServerOrigin` already rejects for the same
+ * reason one line down.
+ *
+ * The cost of getting this wrong is silence: the bundle renders, the server reports a
+ * successful recompile, and edits never arrive.
+ */
+export declare const hotSocketIsDialable: (devServer: DevServerOptions) => boolean;
+export declare const devServerOrigin: (devServer: DevServerOptions) => string | undefined;
+/**
+ * Records where this package is being served from while a dev server is running, so tooling
+ * can offer it instead of asking a developer to repeat a port they have already
+ * configured. Written on every serve build and left to be cleaned with the output
+ * directory; nothing removes it when the server stops, which is exactly why a reader
+ * must confirm the origin rather than trust the file.
+ */
+export declare const writeDevHint: (outputDir: string, devServer: DevServerOptions, remoteEntryPath: string, now?: Date) => DevHint | undefined;
+/** webpack-dev-server sets this itself, however webpack was invoked. */
+export declare const isServing: () => boolean;
+export {};

package/dist/types/webpack-plugin/src/index.d.ts

@@ -3,4 +3,6 @@
  */
 export type { AppshellManifest } from '@appshell/config';
 export { default as AppshellPlugin } from './AppshellPlugin';
-//# sourceMappingURL=index.d.ts.map
+export { DEV_HINT_FILE, DEV_HINT_VERSION, devServerOrigin, writeDevHint } from './devHint';
+export type { DevHint } from './devHint';
+export { appshellShared, type AppshellSharedOptions } from './shared';

package/dist/types/webpack-plugin/src/shared.d.ts

@@ -0,0 +1,36 @@
+import type { SharedObject } from '@appshell/config';
+export type AppshellSharedOptions = {
+    /** Include the React bindings and React itself. */
+    react?: boolean;
+    /**
+     * Usually your package.json `dependencies`. Anything named here is pinned to the range
+     * you depend on; anything absent is left for module federation to infer, which it does
+     * from the installed package.
+     */
+    dependencies?: Record<string, string>;
+    /** Merged last, so a package can still say something the preset does not. */
+    extra?: SharedObject;
+};
+/**
+ * The `shared` block an Appshell package needs, so it is not written out by hand in every
+ * webpack config and wrong in one of them.
+ *
+ * It exists because the alternative failed in practice: the examples in this repo declared
+ * `@appshell/react` as a singleton in three configs and omitted it in a fourth, which is
+ * silent until a root package calls `useRemote()` and gets `undefined`.
+ *
+ * `AppshellPlugin` cannot inject this itself — `ModuleFederationPlugin` reads its own
+ * options during its `apply`, which webpack has already run by the time it reaches ours.
+ * Spread into your own config, it sidesteps plugin ordering entirely:
+ *
+ * ```js
+ * const { appshellShared } = require('@appshell/webpack-plugin');
+ * const { dependencies } = require('./package.json');
+ *
+ * new ModuleFederationPlugin({
+ *   shared: appshellShared({ react: true, dependencies }),
+ * });
+ * ```
+ */
+export declare const appshellShared: ({ react, dependencies, extra, }?: AppshellSharedOptions) => SharedObject;
+export default appshellShared;

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@appshell/webpack-plugin",
-  "version": "1.0.0-alpha.9",
+  "version": "1.0.0-alpha.91",
   "description": "Webpack plugin used to generate a global Appshell configuration for micro-frontends built with Module Federation",
   "main": "dist/main.js",
   "types": "dist/types/webpack-plugin/src/index.d.ts",
-  "repository": "https://github.com/appshell-org/appshell.git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/appshellhq/appshell.git"
+  },
   "author": "Robert Hamilton <rh@navaris.com>",
   "publishConfig": {
     "access": "public",
@@ -17,7 +20,8 @@
     "clean": "rm -rf dist",
     "prebuild": "npm run clean",
     "start": "webpack --watch --mode development && npm run build:types",
-    "stats": "webpack --json > stats.json"
+    "stats": "webpack --json > stats.json",
+    "typecheck": "tsc --noEmit"
   },
   "files": [
     "dist"
@@ -29,5 +33,8 @@
     "plugin"
   ],
   "license": "MIT",
-  "gitHead": "dd1cd33cf2f014563438d29a004ce7939e65dacb"
+  "gitHead": "beb3e1dc02a4c32424f163da35e9ce43ee3bdb82",
+  "dependencies": {
+    "@appshell/tokens": "^1.0.0-alpha.91"
+  }
 }

package/dist/types/config/src/axios.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"axios.d.ts","sourceRoot":"","sources":["../../../../../config/src/axios.ts"],"names":[],"mappings":";AAEA,wBAA8B"}

package/dist/types/config/src/configmap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"configmap.d.ts","sourceRoot":"","sources":["../../../../../config/src/configmap.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;;YA0BrC,CAAC,SAAS,MAAM,OAAO,CAAC,aAAa,SAAS,KAAG,CAAC;qBAuBzC,cAAc;;AAEtC,wBAGE"}

package/dist/types/config/src/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../../config/src/context.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAaF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAAO,eAQjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,QAAO;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAK5E,CAAC"}

package/dist/types/config/src/credentials.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../../../../../config/src/credentials.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,UAAU,GAAG;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAKF,eAAO,MAAM,eAAe,cAC6D,CAAC;AAqB1F,eAAO,MAAM,cAAc,aAAc,MAAM,cAAc,UAAU,SAEtE,CAAC;AAEF,eAAO,MAAM,eAAe,aAAc,MAAM,SAI/C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,aAAc,MAAM,KAAG,MAAM,GAAG,SAexD,CAAC;AAEF,eAAO,MAAM,YAAY,aAAc,MAAM,KAAG,MAO/C,CAAC"}

package/dist/types/config/src/deregister.d.ts

@@ -1,3 +0,0 @@
-declare const _default: (moduleName: string, registry: string) => Promise<void>;
-export default _default;
-//# sourceMappingURL=deregister.d.ts.map

package/dist/types/config/src/deregister.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deregister.d.ts","sourceRoot":"","sources":["../../../../../config/src/deregister.ts"],"names":[],"mappings":"qCAoGkC,MAAM,YAAY,MAAM;AAA1D,wBAeE"}

package/dist/types/config/src/generate.env.d.ts

@@ -1,3 +0,0 @@
-declare const _default: (prefix?: string) => Promise<Map<string, string | undefined>>;
-export default _default;
-//# sourceMappingURL=generate.env.d.ts.map

package/dist/types/config/src/generate.env.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate.env.d.ts","sourceRoot":"","sources":["../../../../../config/src/generate.env.ts"],"names":[],"mappings":";AAGA,wBAuBK"}

package/dist/types/config/src/generate.global-config.d.ts

@@ -1,10 +0,0 @@
-import { AppshellGlobalConfig } from './types';
-type GenerateGlobalConfigOptions = {
-    insecure: boolean;
-    apiKey?: string;
-    apiKeyHeader?: string;
-    proxyUrl?: string;
-};
-declare const _default: (registries: string[], options?: GenerateGlobalConfigOptions) => Promise<AppshellGlobalConfig>;
-export default _default;
-//# sourceMappingURL=generate.global-config.d.ts.map

package/dist/types/config/src/generate.global-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate.global-config.d.ts","sourceRoot":"","sources":["../../../../../config/src/generate.global-config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAK/C,KAAK,2BAA2B,GAAG;IACjC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;qCAGY,MAAM,EAAE,YACX,2BAA2B,KACnC,OAAO,CAAC,oBAAoB,CAAC;AAHhC,wBA8CE"}