@blotch/rsbuild-plugin-angular-lynx 22.2.2 → 22.2.4

package/dist/layers.d.ts

@@ -1,9 +1,11 @@
 import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
 /**
- * Webpack layer names for the dual-thread build. Each entry is duplicated
- * into two webpack entries with different layers — the layer determines which
- * SWC target (ES2015 vs ES2019) and which thread-specific configuration
- * (CSS extraction vs ignore, AMD wrapping vs plain) applies to the module.
+ * Webpack layer names for the dual-thread build. Each entry is split into two
+ * webpack entries with different layers (entry.ts), and every module an entry
+ * reaches stays in its layer. The layer determines which SWC target (ES2015 vs
+ * ES2019), which `__MAIN_THREAD__` value and which thread-specific
+ * configuration (CSS extraction vs ignore, AMD wrapping vs plain) applies to
+ * the module.
  */
 export declare const LAYERS: {
     BACKGROUND: string;

package/dist/logger/dev-logger-middleware.d.ts

@@ -1,12 +1,18 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
-export declare const formatArg: (arg: unknown) => string;
-export declare const getLogFilePath: () => string;
 /**
- * Creates a connect-style middleware that handles POST /__dev_logs.
- * Other requests are passed through to the next middleware.
+ * Connect-style middleware that receives log batches from on-device and
+ * writes them to a log file. Rspeedy's TUI uses the alternate screen buffer,
+ * so stdout writes are hidden — a file + `tail -f` is more reliable.
  */
+/** The dev server path the app posts its log entries to. */
+export declare const DEV_LOGS_PATH = "/__dev_logs";
+export declare const formatArg: (arg: unknown) => string;
 /**
- * Creates a connect-style middleware that handles POST /__dev_logs.
- * Other requests are passed through to the next middleware.
+ * Creates a connect-style middleware that handles POST /__dev_logs and writes
+ * the entries to `logFilePath`. Other requests are passed through to the next
+ * middleware.
+ *
+ * The file is created, or emptied, right away: each dev server start begins a
+ * fresh log, and `tail -f` can follow it before the first entry arrives.
  */
-export declare const createDevLoggerMiddleware: () => ((req: IncomingMessage, res: ServerResponse, next: () => void) => void);
+export declare const createDevLoggerMiddleware: (logFilePath: string) => ((req: IncomingMessage, res: ServerResponse, next: () => void) => void);

package/dist/logger/dev-logger.d.ts

@@ -1,2 +1,15 @@
 import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+/**
+ * Receives `LynxLogger` entries from the app on the dev server itself, and
+ * writes them to `.dev-logs`. Also injects __DEV_LOG_URL__ at compile time so
+ * the runtime knows where to POST logs (rspack's __webpack_public_path__ isn't
+ * accessible as a globalThis property in Lynx's JS environment).
+ *
+ * The endpoint is a middleware on the dev server, at the origin the app loads
+ * its bundle from, rather than a server of its own on a port next to it. The
+ * phone can already reach that origin, and its port is the one rspeedy
+ * resolved: a second server had to guess its port when the bundle was
+ * compiled, and when that port was taken it moved to another one while the
+ * app kept posting to the first, so the logs were lost.
+ */
 export declare const applyDevLogger: (api: RsbuildPluginAPI) => void;

package/dist/polyfills.js

@@ -40,6 +40,62 @@ if ("u" < typeof AbortController) {
     };
 }
 if ('function' != typeof Object.hasOwn) Object.hasOwn = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+const definePolyfillOverride = (proto, name, value)=>{
+    Object.defineProperty(proto, name, {
+        value,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+};
+const definePolyfill = (proto, name, value)=>{
+    if (proto && 'function' != typeof proto[name]) definePolyfillOverride(proto, name, value);
+};
+const relativeIndex = function(index) {
+    const length = this.length;
+    let n = Math.trunc(Number(index)) || 0;
+    if (n < 0) n += length;
+    if (n < 0 || n >= length) return;
+    return 'string' == typeof this ? this.charAt(n) : this[n];
+};
+definePolyfill(Array.prototype, 'at', relativeIndex);
+definePolyfill(String.prototype, 'at', function(index) {
+    return relativeIndex.call(String(this), index);
+});
+if ('function' == typeof Int8Array) definePolyfill(Object.getPrototypeOf(Int8Array.prototype), 'at', relativeIndex);
+definePolyfill(Array.prototype, 'findLastIndex', function(predicate, thisArg) {
+    for(let i = this.length - 1; i >= 0; i--)if (predicate.call(thisArg, this[i], i, this)) return i;
+    return -1;
+});
+definePolyfill(Array.prototype, 'findLast', function(predicate, thisArg) {
+    for(let i = this.length - 1; i >= 0; i--)if (predicate.call(thisArg, this[i], i, this)) return this[i];
+});
+definePolyfill(String.prototype, 'replaceAll', function(search, replacement) {
+    const subject = String(this);
+    if (search instanceof RegExp) {
+        if (!search.global) throw new TypeError('replaceAll must be called with a global RegExp');
+        return subject.replace(search, replacement);
+    }
+    const needle = String(search);
+    const pattern = new RegExp(needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+    return subject.replace(pattern, replacement);
+});
+if ("u" < typeof Intl) definePolyfillOverride(Number.prototype, 'toLocaleString', function(_locales, options) {
+    const value = Number(this);
+    if (Number.isNaN(value)) return 'NaN';
+    if (!Number.isFinite(value)) return value > 0 ? '∞' : '-∞';
+    const opts = options || {};
+    const min = opts.minimumFractionDigits ?? 0;
+    const max = Math.max(min, opts.maximumFractionDigits ?? Math.max(min, 3));
+    const fixed = Math.abs(value).toFixed(max);
+    const dot = fixed.indexOf('.');
+    let integer = dot < 0 ? fixed : fixed.slice(0, dot);
+    let fraction = dot < 0 ? '' : fixed.slice(dot + 1).replace(/0+$/, '');
+    while(fraction.length < min)fraction += '0';
+    if (false !== opts.useGrouping) integer = integer.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+    const sign = value < 0 && 0 !== Number(fixed) ? '-' : '';
+    return sign + integer + (fraction ? `.${fraction}` : '');
+});
 if ('function' != typeof Promise.allSettled) Promise.allSettled = (promises)=>Promise.all(Array.from(promises, (p)=>Promise.resolve(p).then((value)=>({
                 status: 'fulfilled',
                 value

package/dist/polyfills.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pure-classes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Wraps each top-level class with private or static members in a pure IIFE,
+ * so a bundler can drop the classes nothing uses.
+ *
+ * The background layer compiles to ES2015 (layers.ts), so SWC lowers private
+ * and static class fields. A class declaration keeps its own statement, but the
+ * class expressions that bundled libraries are written in (`var X = class
+ * {…}`) become a sequence that assigns each private field's `WeakMap` to an
+ * outer variable: `var X = (_a = new WeakMap(), class {…})`. The assignment
+ * counts as a side effect, so rspack keeps every such class, and every import
+ * it uses, even when nothing uses the class. The runtime's own classes are
+ * like that (it uses `#private` fields throughout), which kept Angular's
+ * renderer and change detection in the background bundle.
+ *
+ * Angular's build already wraps a class whose static members are Angular's
+ * own (`ɵcmp`, `ɵfac` and so on) in `/*#__PURE__*\/ (() => {…})()`; this does
+ * the same for the rest. Inside the IIFE, the lowering's assignments are local
+ * and the call is marked pure. A class whose static members could have side
+ * effects of their own (anything but literals, functions and new collections)
+ * is left alone.
+ *
+ * @param code - The module's code, before SWC lowers it (and, for a `.ts`
+ *   file, strips its types).
+ * @param filename - The module's path, for the parser.
+ * @returns The transformed code, or `code` itself when nothing applies.
+ */
+export declare const wrapPureClasses: (code: string, filename: string) => string;

package/dist/pure-classes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/resolve.d.ts

@@ -0,0 +1,19 @@
+import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+/**
+ * Resolves `import`s to a package's ES module build.
+ *
+ * The Lynx build engine resolves every request with the conditions `lynx`,
+ * `import`, `require` and `browser`, whether it comes from an `import` or a
+ * `require()`. A package whose `exports` list `require` before any of the
+ * others then resolves to its CommonJS build even from an `import`. rxjs is
+ * one (`types`, `node`, `require`, `es2015`, `default`), and Angular and the
+ * runtime import it everywhere. CommonJS can't be tree-shaken, so every app
+ * carried all of rxjs on both threads, about 130 kB of each bundle, when the
+ * background thread uses `Subject` alone.
+ *
+ * So `import`s get the engine's conditions without `require`, and with
+ * `module` after `import`, as webpack's defaults have them (tslib's ES module
+ * build is behind `module`). A `require()` still resolves with all of the
+ * engine's conditions.
+ */
+export declare const applyResolve: (api: RsbuildPluginAPI) => void;

package/dist/resolve.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/split-chunks.d.ts

@@ -1,3 +1,3 @@
 import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
-import type { PluginAngularLynxOptions } from './utils/options.js';
-export declare const applySplitChunksRule: (api: RsbuildPluginAPI, options: Required<PluginAngularLynxOptions>) => void;
+import type { NormalizedPluginAngularLynxOptions } from './utils/options.js';
+export declare const applySplitChunksRule: (api: RsbuildPluginAPI, options: NormalizedPluginAngularLynxOptions) => void;

package/dist/styles/blur-view.css

@@ -0,0 +1,16 @@
+/*
+ * The look of iOS's blur-view materials on Android, where Lynx's blur-view
+ * only blurs. On Android the runtime sets these variables inline on every
+ * blur-view (see android-blur-material.ts in @blotch/angular-lynx); iOS leaves
+ * them unset, so the fallbacks apply there and change nothing.
+ *
+ * The type selector is what lets the app restyle a blur-view: it loses to any
+ * class, id or inline style, so `bg-white/30` or `shadow-none` still wins.
+ * The build adds this file to the native bundle first, so an app's own
+ * `blur-view` rule comes later and wins too. Web draws its materials itself.
+ */
+blur-view {
+  background-color: var(--angular-lynx-blur-background, transparent);
+  background-image: var(--angular-lynx-blur-background-image, none);
+  box-shadow: var(--angular-lynx-blur-box-shadow, none);
+}

package/dist/tailwind-v4/calc.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Folds every `calc()` in a value whose terms are all constants, such as the
+ * `calc(45deg * -1)` and `calc(calc(1 / 2 * 100%) * -1)` Tailwind writes for
+ * negative and fractional transforms, into a single value (`-45deg`, `-50%`).
+ *
+ * Lynx evaluates `calc()` in lengths, but not everywhere a transform function
+ * takes an angle, a number or a percentage, so the transform values are
+ * folded before they reach it. A `calc()` with `var()` or mixed units stays
+ * as it is. So does `infinity`, which Lynx doesn't read.
+ */
+export declare const foldCalc: (value: string) => string;
+/**
+ * Replaces a number written with an exponent of 7 or more, with the stand-in
+ * for `infinity`. In a production build Tailwind minifies with Lightning CSS,
+ * which folds `rounded-full`'s `calc(infinity * 1px)` to the largest float,
+ * `3.40282e38px`, and Lynx doesn't read an exponent.
+ */
+export declare const clampHugeNumbers: (value: string) => string;

package/dist/tailwind-v4/calc.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind-v4/colors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Rewrites every color function in a declaration value that it can evaluate
+ * statically. A function with `var()`, `calc()` or another dynamic part stays
+ * as it is: Lynx drops it, as before.
+ */
+export declare const lowerColors: (value: string, channelVariables?: ReadonlySet<string>) => string;

package/dist/tailwind-v4/colors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind-v4/declarations.d.ts

@@ -0,0 +1,39 @@
+import type { Root, Rule } from 'postcss';
+/**
+ * Rewrites the declarations Tailwind CSS 4 writes into ones Lynx reads. Each
+ * rewrite keeps what the declaration means on the web, so the web preview
+ * and the native app keep matching.
+ */
+/**
+ * The single `transform` the `translate-*`, `rotate-*`, `scale-*`, `skew-*`
+ * and `rotate-{x,y,z}-*` utilities all write, composed from the variables
+ * each of them sets.
+ *
+ * Tailwind 4 writes the `translate`, `rotate` and `scale` properties, which
+ * Lynx doesn't have, so the utilities would do nothing on device. Lynx's own
+ * Tailwind 3 preset composes the same way. The order is the one CSS applies
+ * the individual properties in: translate, rotate, scale, then `transform`.
+ */
+export declare const COMPOSED_TRANSFORM: string;
+/**
+ * The starting values of the variables {@link COMPOSED_TRANSFORM} reads that
+ * must be set for it to parse. The others have empty fallbacks.
+ */
+export declare const TRANSFORM_DEFAULTS: ReadonlyMap<string, string>;
+/** What lowering a rule's declarations found, for the defaults rule. */
+export type LoweredRule = {
+    /** Whether the rule now writes {@link COMPOSED_TRANSFORM}. */
+    readonly composesTransform: boolean;
+};
+/**
+ * Lowers every declaration of one rule. Works on the rule as a whole because
+ * the transform properties collapse into one declaration. `channelVariables`
+ * are the colors the stylesheet gives a `-rgb` channel variable (see
+ * colors.ts).
+ */
+export declare const lowerDeclarations: (rule: Rule, channelVariables?: ReadonlySet<string>) => LoweredRule;
+/**
+ * Lowers the values of the transform variables, once the variables in them
+ * are resolved (see variables.ts): `calc(0.25rem * 2)` folds to `0.5rem`.
+ */
+export declare const lowerTransformVariables: (root: Root) => void;

package/dist/tailwind-v4/declarations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind-v4/index.d.ts

@@ -0,0 +1,23 @@
+import type { PluginCreator, Root, Rule } from 'postcss';
+/**
+ * A PostCSS plugin that makes the CSS Tailwind CSS 4 writes work on Lynx. It
+ * runs after `@tailwindcss/postcss`, and only on the stylesheets Tailwind
+ * compiled, so every other stylesheet reaches Lynx as it was written.
+ *
+ * Tailwind 4 writes CSS for current browsers: cascade layers, `@property`,
+ * nesting, `oklch()` colors, `color-mix()`, logical properties and the
+ * individual `translate`/`rotate`/`scale` properties. Lynx reads none of
+ * them, and mostly drops them without a warning, while Lynx for Web passes
+ * them to the browser, so the web preview looks right and the app doesn't.
+ * Lynx's Tailwind preset avoids this for Tailwind 3 by changing the
+ * utilities; Tailwind 4 has no switch to turn its core utilities off, so this
+ * rewrites its output instead, into CSS with the same meaning that Lynx
+ * reads, on native and on the web alike. See
+ * investigations/lynx-vs-web-differences.md for what Lynx does with each.
+ */
+export declare const tailwindForLynx: PluginCreator<void>;
+/**
+ * Lowers a stylesheet Tailwind 4 compiled. `createRule` makes the rule that
+ * holds the variables' starting values.
+ */
+export declare const lowerForLynx: (root: Root, createRule: (selector: string) => Rule) => void;

package/dist/tailwind-v4/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind-v4/lynx-properties.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Every CSS property Lynx has, from the definitions its CSS engine is
+ * generated from (lynx-family/lynx, tools/css_generator/css_defines, as of
+ * October 2026). Add a property here when Lynx adds one.
+ *
+ * Tailwind CSS 4 has no way to turn a core utility off, and it generates
+ * every class it finds in the source, even a word in a string such as
+ * `uppercase`. Lynx drops a property it doesn't have, with a build warning,
+ * but Lynx for Web passes it to the browser, so the web preview would show
+ * styles the app never gets. Tailwind 3 avoided this with the Lynx preset's
+ * list of core plugins.
+ */
+export declare const LYNX_PROPERTIES: ReadonlySet<string>;
+/**
+ * The keywords each of Lynx's keyword-only properties takes, from the same
+ * definitions. Tailwind 4 writes values Lynx doesn't have for some of them
+ * (`display: inline`, `position: static`, `white-space: pre`), which Lynx drops and
+ * the web preview would apply; the Lynx preset left those utilities out.
+ */
+export declare const LYNX_KEYWORDS: ReadonlyMap<string, ReadonlySet<string>>;

package/dist/tailwind-v4/selectors.d.ts

@@ -0,0 +1,6 @@
+import type { Rule } from 'postcss';
+/**
+ * Rewrites the selectors Tailwind CSS 4 writes into ones Lynx matches.
+ * Returns `false` when no selector is left, so the caller removes the rule.
+ */
+export declare const lowerSelectors: (rule: Rule) => boolean;

package/dist/tailwind-v4/selectors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind-v4/structure.d.ts

@@ -0,0 +1,51 @@
+import type { Container, Root } from 'postcss';
+/**
+ * Unwraps the CSS structure Tailwind CSS 4 writes and Lynx can't read:
+ * nesting, `@layer` blocks and `@property` registrations.
+ */
+/**
+ * Moves nested rules and at-rules out to the top level, the way Sass does:
+ * `.a { &:hover { … } }` becomes `.a:hover { … }`, and
+ * `.a { @media (…) { … } }` becomes `@media (…) { .a { … } }`.
+ *
+ * Tailwind 4 writes its variants nested (`hover:`, `md:`, the `@supports`
+ * fallback of an opacity modifier). Lynx's CSS parser reads a nested rule as
+ * a descendant selector and never sees the `&`, and Lynx for Web throws on
+ * it, so neither applies them. A production build already arrives flattened
+ * (Tailwind minifies with Lightning CSS); a development build doesn't.
+ */
+export declare const flattenNesting: (root: Root) => void;
+/**
+ * Replaces every `@layer` block with its contents and drops `@layer`
+ * statements.
+ *
+ * Lynx ignores a rule inside `@layer`, on native and on the web, so none of
+ * Tailwind 4's CSS would apply. Tailwind writes its layers in cascade order
+ * (theme, base, components, utilities), so keeping the source order keeps
+ * the cascade between them.
+ */
+export declare const unwrapLayers: (container: Container) => void;
+/**
+ * Removes the `@property` registrations and returns the custom properties
+ * that have an initial value, with that value.
+ *
+ * Lynx has no `@property`, so a variable Tailwind registers with an initial
+ * value (`--tw-border-style: solid`, `--tw-translate-x: 0`) is unset until a
+ * utility sets it, and every value that reads it breaks: `border` draws no
+ * border. A registration without an initial value is left out on purpose: the
+ * variable stays unset, so the `var()` fallbacks Tailwind writes apply.
+ */
+export declare const takePropertyRegistrations: (root: Root) => Map<string, string>;
+/**
+ * Removes the rules and at-rules the steps above left empty, such as a
+ * nested rule's parent that held only nested rules.
+ */
+export declare const removeEmptyContainers: (container: Container) => void;
+/**
+ * Writes out the `from` and `to` keyframes an animation leaves implied.
+ *
+ * Lynx doesn't play an animation that lacks either, and Tailwind's `spin`
+ * has only `to`, `ping` no `from`, and `pulse` neither, so `animate-spin`
+ * did nothing on device.
+ */
+export declare const completeKeyframes: (root: Root) => void;

package/dist/tailwind-v4/structure.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind-v4/variables.d.ts

@@ -0,0 +1,20 @@
+import type { Root } from 'postcss';
+/**
+ * Resolves the `var()` references that Lynx can't, inside the custom
+ * properties Tailwind CSS 4 sets.
+ *
+ * Lynx substitutes a `var()` that a custom property's value holds directly
+ * (`--tw-gradient-from: var(--color-red-500)`), but not one inside another
+ * function: `--tw-translate-x: calc(var(--spacing) * 2)` and
+ * `--tw-blur: blur(var(--blur-sm))` leave the property invalid, so the
+ * utility does nothing on device. That holds even when the variable is set
+ * in the same rule or the `var()` has a fallback.
+ *
+ * Each such reference becomes a value this stylesheet already knows: the
+ * variable's declaration in the same rule, else its theme value (the
+ * `:root` rule Tailwind writes), else the reference's fallback, else the
+ * initial value Tailwind registered with `@property`. Only a variable set by
+ * another utility on the same element, such as `ring-offset-2`'s width under
+ * `ring-2`, loses its effect, since the value is now fixed.
+ */
+export declare const resolveNestedVariables: (root: Root, registrations: ReadonlyMap<string, string>) => void;

package/dist/tailwind-v4/variables.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind.d.ts

@@ -1,2 +1,16 @@
 import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+/**
+ * Sets Tailwind CSS up for the app, either version:
+ *
+ * - **Tailwind 3** runs when the app has a `tailwind.config.*`, the way
+ *   Angular CLI sets it up. Its config uses `@lynx-js/tailwind-preset`.
+ * - **Tailwind 4** runs when the app's PostCSS config lists
+ *   `@tailwindcss/postcss` (`.postcssrc.json`, which `ng add` writes as
+ *   Angular CLI's own Tailwind setup does). Rsbuild loads that config itself.
+ *
+ * Either way, a PostCSS plugin added after Tailwind rewrites the CSS
+ * Tailwind 4 writes into CSS Lynx reads (see tailwind-v4/index.ts). It only
+ * touches the stylesheets Tailwind 4 compiled, so it adds nothing to a
+ * Tailwind 3 build or a build without Tailwind.
+ */
 export declare const applyTailwind: (api: RsbuildPluginAPI) => void;

package/dist/transform-module.d.ts

@@ -1,4 +1,16 @@
-import type { ComponentScopeInfo, ComponentStylesEntry } from './component-styles-cache.js';
+/**
+ * The stylesheets extracted from one module's components (see
+ * component-styles.ts), written as CSS files.
+ */
+export type ModuleStylesheets = {
+    /** The CSS files, in the order the module's components declare them. */
+    imports: string[];
+    /** Each Emulated component's class name and the scope ID its CSS uses. */
+    scopes: Array<{
+        className: string;
+        scopeId: string;
+    }>;
+};
 /**
  * Transforms the Angular-compiled JS for a single component module before rspack
  * bundles it. This is the per-module half of the AngularLynx pipeline, extracted
@@ -6,26 +18,40 @@ import type { ComponentScopeInfo, ComponentStylesEntry } from './component-style
  * string→string function (no rspack loader context, no compilation cache).
  *
  * It applies, in order:
- *   1. Prepends `import "<scoped.css>"` statements for the component's scoped
- *      stylesheets (resolved relative to the component file).
- *   2. Appends the `Component.ɵcmp.id = '<scopeId>'` assignment that ties the CSS
- *      files (whose filenames carry the same scope ID) to the runtime component.
+ *   1. Prepends `import "<component.css>"` statements for the stylesheets
+ *      extracted from the module's components (resolved relative to the
+ *      component file).
+ *   2. Appends a `Component.ɵcmp.id = '<scopeId>'` assignment for each
+ *      Emulated component, which ties its scoped CSS to its renderer.
  *   3. Runs the worklet ("main thread" directive) transform over the result.
+ *   4. Runs the cross-thread transform (cross-thread-transform.ts), which gives
+ *      module-level background functions and refs IDs that match on both
+ *      threads.
+ *   5. In a development build with hot updates (`hot` is set), makes the
+ *      module take them (hot-updates.ts): an entry module re-bootstraps the
+ *      app, and a module that defines components updates them in place when
+ *      only their templates or styles changed. Other modules pass their
+ *      updates on to the modules that import them.
  *
- * It deliberately does NOT make the bootstrap entry accept its own hot
- * updates (`module.hot.accept()`), which an earlier version did. On Lynx the
- * screen is drawn by the Angular app on the main thread, but webpack HMR only
- * runs on the background thread: nothing loads the main-thread hot-update
- * chunk. A self-accepting entry let the background thread apply the update
- * and re-bootstrap its own copy of the app, so HMR reported success and the
- * main thread kept rendering the old code until a manual reload. With no
- * module accepting, the update aborts and the Lynx HMR client
- * (`@lynx-js/webpack-dev-transport`) falls back to a full `Page.reload`, which
- * re-runs both threads with the new bundle.
+ * The hot update clients apply each update on both threads (see client/).
+ * Before they did, only the background thread took hot updates, so a
+ * self-accepting entry (which an earlier version had) re-bootstrapped the
+ * background thread's copy of the app while the main thread, which draws the
+ * screen, kept running the old code.
  */
 export declare const buildTransformedCode: (params: {
     code: string;
     resourcePath: string;
-    componentStyles: Pick<ComponentStylesEntry, "imports"> | undefined;
-    scopeInfo: ComponentScopeInfo | undefined;
+    stylesheets: ModuleStylesheets | undefined;
+    /** The project root, which cross-thread IDs are relative to. */
+    root: string;
+    /**
+     * Set in a development build with hot updates. `entry` says whether the
+     * module is one of the app's entries, and `source` reads its TypeScript
+     * source.
+     */
+    hot?: {
+        entry: boolean;
+        source: () => string;
+    };
 }) => string;

package/dist/utils/angular/component-scope-id.d.ts

@@ -5,8 +5,10 @@
  * (for "Lynx") differentiates these from Angular's default 'ng' prefix IDs,
  * preventing collisions if browser-Angular scope IDs leak into shared code.
  * This ID appears in:
- *   - CSS filenames: `...__scoped_l<hash>.css`
- *   - ɵcmp.id: patched at the end of angular.ts transform
- *   - _nghost-l<hash> class: added by EmulatedLynxRenderer.selectRootElement()
+ *   - the component's compiled CSS: `.title._ngcontent-l<hash>`,
+ *     `._nghost-l<hash>` (see component-styles.ts)
+ *   - ɵcmp.id: set by the loader (see transform-module.ts)
+ *   - the `_ngcontent-l<hash>` and `_nghost-l<hash>` classes that
+ *     EmulatedLynxRenderer adds to the component's elements
  */
 export declare const generateComponentScopeId: (className: string, containingFile: string) => string;

package/dist/utils/options.d.ts

@@ -2,14 +2,29 @@ export type PluginAngularLynxOptions = {
     customCSSInheritanceList?: string[] | undefined;
     debugInfoOutside?: boolean;
     defaultDisplayLinear?: boolean;
+    /**
+     * Make `overflow: visible` the default for every element, as on the web.
+     * With `false`, elements clip their children unless they set `overflow`,
+     * Lynx's older default.
+     */
     defaultOverflowVisible?: boolean;
     enableA11y?: boolean;
     enableAccessibilityElement?: boolean;
     enableCSSInheritance?: boolean;
     enableCSSInvalidation?: boolean;
     enableCSSSelector?: boolean;
+    /**
+     * @deprecated Has no effect, and never did: it was never passed to Lynx.
+     * Lynx's template plugin and React Lynx dropped it too. Will be removed in
+     * a future release.
+     */
     enableICU?: boolean;
     enableNewGesture?: boolean;
+    /**
+     * @deprecated Has no effect, and never did: it was never passed to Lynx.
+     * Lynx's template plugin and React Lynx dropped it too. Will be removed in
+     * a future release.
+     */
     enableParallelElement?: boolean;
     enableRemoveCSSScope?: boolean;
     enableSSR?: boolean;
@@ -23,9 +38,33 @@ export type PluginAngularLynxOptions = {
      * When omitted, uses `source.entry` from lynx.config.ts (single or multi-entry).
      */
     pages?: string[] | 'all' | undefined;
+    /**
+     * @deprecated Has no effect, and never did: it was never passed to Lynx.
+     * Lynx's template plugin and React Lynx dropped it too. Will be removed in
+     * a future release.
+     */
     pipelineSchedulerConfig?: number;
     removeDescendantSelectorScope?: boolean;
     targetSdkVersion?: string;
     experimental_isLazyBundle?: boolean;
 };
-export declare const normalizeOptions: (options?: Partial<PluginAngularLynxOptions>) => Required<PluginAngularLynxOptions>;
+/**
+ * Options the plugin still accepts, so existing `lynx.config.ts` files keep
+ * type-checking, but ignores. They were declared and given defaults but never
+ * passed to Lynx, and `@lynx-js/template-webpack-plugin` 0.9 removed them
+ * (lynx-family/lynx-stack#1705, #1800), so there's nothing to pass them to:
+ *
+ * - `enableParallelElement` and `pipelineSchedulerConfig` turn on Lynx's
+ *   experimental parallel element resolution, which React Lynx turned off for
+ *   stability.
+ * - `enableICU` binds a host-provided ICU service (`LynxServiceI18nProtocol`
+ *   on iOS, `ICURegister` on Android) into the JS context. Lynx Explorer and
+ *   the apps `ng build --platform` makes don't provide one.
+ */
+export declare const DEPRECATED_OPTIONS: readonly ["enableICU", "enableParallelElement", "pipelineSchedulerConfig"];
+type DeprecatedOption = (typeof DEPRECATED_OPTIONS)[number];
+export type NormalizedPluginAngularLynxOptions = Required<Omit<PluginAngularLynxOptions, DeprecatedOption>>;
+/** The deprecated options `options` sets, to warn about. */
+export declare const deprecatedOptionsIn: (options?: Partial<PluginAngularLynxOptions>) => DeprecatedOption[];
+export declare const normalizeOptions: (options?: Partial<PluginAngularLynxOptions>) => NormalizedPluginAngularLynxOptions;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blotch/rsbuild-plugin-angular-lynx",
-  "version": "22.2.2",
+  "version": "22.2.4",
   "description": "Rsbuild plugin for building AngularLynx applications",
   "homepage": "https://github.com/Blotch-Smart-Frames/AngularLynx#readme",
   "bugs": {
@@ -45,7 +45,7 @@
     "@lynx-js/runtime-wrapper-webpack-plugin": "^0.2.4",
     "@lynx-js/template-webpack-plugin": "^0.16.2",
     "@lynx-js/webpack-runtime-globals": "^0.0.8",
-    "rsbuild-plugin-tailwindcss": "0.2.4",
+    "postcss-value-parser": "^4.2.0",
     "tiny-invariant": "^1.3.3"
   },
   "devDependencies": {
@@ -54,7 +54,10 @@
     "@rsbuild/core": "^2.2.9",
     "@rslib/core": "^0.21.4",
     "@rspack/core": "^2.2.8",
+    "@tailwindcss/postcss": "^4.3.3",
     "@types/node": "^25.6.2",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.3.3",
     "type-fest": "^5.6.0",
     "typescript": "^6.0.3"
   },

package/dist/loaders/thread-globals-loader.d.ts

@@ -1,8 +0,0 @@
-import type { Rspack } from '@rsbuild/core';
-/**
- * Prepends `globalThis["__MAIN_THREAD__"]=<value>;` to every module in the layer.
- * Replaces the BannerPlugin approach — injections happen per-module during
- * compilation instead of per-chunk after bundling.
- */
-declare const threadGlobalsLoader: (this: Rspack.LoaderContext, source: string) => string;
-export default threadGlobalsLoader;