ALIAS: legacy -webkit- aliases of supported properties resolve as in Chrome (44 aliases)

.github/workflows/device-lanes.yml

@@ -15,6 +15,11 @@ on:
         description: Commit to run the device lanes of (it must be reachable from a branch of this repository)
         required: true
         type: string
+      judge:
+        description: Judge the lanes against the commit's own committed records (false only for the landing driver, which judges against its previous position)
+        required: false
+        default: true
+        type: boolean
   pull_request:
     types: [labeled]
 permissions:
@@ -204,18 +209,18 @@ jobs:
           path: ${{ runner.temp }}/outcomes/*.json
       - name: Keep the committed records to compare with
         run: mkdir -p "$RUNNER_TEMP/committed" && cp packages/parity/out/lanes.json packages/parity/out/device-failures-*.json "$RUNNER_TEMP/committed/"
-      # A run for review (the `devices` label) is judged here against the tested commit's records. A run the landing driver
-      # dispatches is not: its tree's records are the "not run" ones its regen wrote, and the driver judges it against the previous
-      # position, as a local run is judged; so the merge and the comparison only report there.
+      # A run for review (the `devices` label, or a manual dispatch) is judged here against the tested commit's records. A run the
+      # landing driver dispatches (judge=false) is not: its tree's records are the "not run" ones its regen wrote, and the driver
+      # judges it against the previous position, as a local run is judged; so the merge and the comparison only report there.
       - name: Merge the device outcomes into the lane records
-        continue-on-error: ${{ github.event_name == 'workflow_dispatch' }}
+        continue-on-error: ${{ github.event_name == 'workflow_dispatch' && !inputs.judge }}
         run: |
           mkdir -p "$RUNNER_TEMP/merge" && cp "$RUNNER_TEMP"/outcomes/*.json "$RUNNER_TEMP/merge/"
           node --conditions=dragon-internal packages/parity/src/cli/device-ci.ts merge "$RUNNER_TEMP/merge"
       - name: Compare every device lane with the committed records
-        continue-on-error: ${{ github.event_name == 'workflow_dispatch' }}
+        continue-on-error: ${{ github.event_name == 'workflow_dispatch' && !inputs.judge }}
         env:
-          JUDGE: ${{ github.event_name == 'pull_request' && '--judge' || '' }}
+          JUDGE: ${{ (github.event_name == 'pull_request' || inputs.judge) && '--judge' || '' }}
         run: |
           # shellcheck disable=SC2086
           node --conditions=dragon-internal packages/parity/src/cli/device-ci.ts compare "$RUNNER_TEMP/committed" $JUDGE

.github/workflows/full-test.yml

@@ -64,10 +64,15 @@ jobs:
       - run: pnpm install --frozen-lockfile
       - name: vitest run packages/layout packages/dragon (but the native file)
         run: |
+          set -o pipefail
           mkdir -p "$RUNNER_TEMP/report"
           list=$(node scripts/test-shards.ts plan platform-free 1 1) || { echo "::error::the shard planner failed"; exit 1; }
           files=(); while IFS= read -r f; do files+=("$f"); done <<< "$list"
-          npx vitest run "${files[@]}" --reporter=default --reporter=json --outputFile="$RUNNER_TEMP/report/platform-free.json"
+          npx vitest run "${files[@]}" --reporter=default --reporter=json --outputFile="$RUNNER_TEMP/report/platform-free.json" 2>&1 | tee "$RUNNER_TEMP/shard.log"
+      - name: No native run was blocked (owner tooling)
+        run: |
+          # The run lines native.ts describe() prints (the test titles that mention "blocked" are not run lines).
+          if grep -nE 'status blocked \(owner tooling\)|native:(swift|kotlin): (swiftc not found|no JDK 17\+ or kotlinc)' "$RUNNER_TEMP/shard.log"; then echo "::error::a native run was blocked (owner tooling): its toolchain was missing, so the test proved nothing"; exit 1; fi
       - uses: actions/upload-artifact@v4
         if: always()
         with:
@@ -131,11 +136,11 @@ jobs:
           mkdir -p "$RUNNER_TEMP/report"
           list=$(node scripts/test-shards.ts plan native ${{ matrix.shard }} 4) || { echo "::error::the shard planner failed"; exit 1; }
           files=(); while IFS= read -r f; do files+=("$f"); done <<< "$list"
-          npx vitest run "${files[@]}" --reporter=default --reporter=json --outputFile="$RUNNER_TEMP/report/native-${{ matrix.shard }}.json" 2>&1 | tee "$RUNNER_TEMP/native.log"
-      - name: No native test ran blocked on a runner with both toolchains
+          npx vitest run "${files[@]}" --reporter=default --reporter=json --outputFile="$RUNNER_TEMP/report/native-${{ matrix.shard }}.json" 2>&1 | tee "$RUNNER_TEMP/shard.log"
+      - name: No native run was blocked (owner tooling)
         run: |
           # The run lines native.ts describe() prints (the test titles that mention "blocked" are not run lines).
-          if grep -nE 'status blocked \(owner tooling\)|native:(swift|kotlin): (swiftc not found|no JDK 17\+ or kotlinc)' "$RUNNER_TEMP/native.log"; then echo "::error::a native run was blocked (owner tooling) on a native shard, which has both toolchains"; exit 1; fi
+          if grep -nE 'status blocked \(owner tooling\)|native:(swift|kotlin): (swiftc not found|no JDK 17\+ or kotlinc)' "$RUNNER_TEMP/shard.log"; then echo "::error::a native run was blocked (owner tooling): its toolchain was missing, so the test proved nothing"; exit 1; fi
       - uses: actions/upload-artifact@v4
         if: always()
         with:
@@ -188,10 +193,15 @@ jobs:
           echo "ANDROID_HOME=${ANDROID_HOME:-unset}"; find "${ANDROID_HOME:-/nonexistent}/platforms" -maxdepth 1 2>&1 | tail -3
       - name: vitest run (every other file, shard ${{ matrix.shard }}/3)
         run: |
+          set -o pipefail
           mkdir -p "$RUNNER_TEMP/report"
           list=$(node scripts/test-shards.ts plan chrome ${{ matrix.shard }} 3) || { echo "::error::the shard planner failed"; exit 1; }
           files=(); while IFS= read -r f; do files+=("$f"); done <<< "$list"
-          npx vitest run "${files[@]}" --reporter=default --reporter=json --outputFile="$RUNNER_TEMP/report/chrome-${{ matrix.shard }}.json"
+          npx vitest run "${files[@]}" --reporter=default --reporter=json --outputFile="$RUNNER_TEMP/report/chrome-${{ matrix.shard }}.json" 2>&1 | tee "$RUNNER_TEMP/shard.log"
+      - name: No native run was blocked (owner tooling)
+        run: |
+          # The run lines native.ts describe() prints (the test titles that mention "blocked" are not run lines).
+          if grep -nE 'status blocked \(owner tooling\)|native:(swift|kotlin): (swiftc not found|no JDK 17\+ or kotlinc)' "$RUNNER_TEMP/shard.log"; then echo "::error::a native run was blocked (owner tooling): its toolchain was missing, so the test proved nothing"; exit 1; fi
       - uses: actions/upload-artifact@v4
         if: always()
         with:

docs/goals/milestone-2-proof/notes/T074-bg2-spec.md

@@ -168,8 +168,12 @@ target. Each diagnostic names the package that lifts it:
   - px and %. em and rem fold to px at compile time, following PNT1's precedent (`analysis/paint-values/radius.ts`
     `computeComponent`; bg2 had refused em).
   - Viewport units and calc() are refused, as PNT1 refuses them.
-  - **Edge offsets** (`right 10px`, `bottom 20%`) are accepted as (100% − x). Chrome computes them to `calc(100% - 10px)`, and
+  - **Edge offsets** (`right 10px`, `bottom 20%`) are accepted. Chrome computes them to the string `calc(100% - 10px)`, and
     chrome-dual proves the string. bg2 refused them.
+    - **PM amendment (2026-10-05, review of #192):** the string is only how getComputedStyle writes the value. For paint, Chrome
+      keeps the right or bottom origin and paints `available − offset` in LayoutUnits, with the offset truncated to a LayoutUnit
+      first (background_image_geometry.cc ResolveXPosition/ResolveYPosition). The engine ports that (paint-gradient.ts
+      `luPosition`), not `100% − x` evaluated in float. The two differ by 1 LU, and that can move a snapped layer by a device px.
   - **content-box** origin and clip on a box with padding are accepted. `DragonBoxShape` gains the padding widths (one named
     hunk at the EMS shape registration point). bg2 refused these because the shape had no padding.
   - Negative stop positions are accepted: Blink normalises them in AddStops, and bg2's port covers that.

docs/ports.json

@@ -101,6 +101,7 @@
         { "lines": "2765-2868", "symbol": null, "source": "cited" }
       ],
       "dragon": [
+        { "file": "packages/dragon/src/analysis/animations.ts", "symbol": "longhandsNamed", "use": "reference" },
         { "file": "packages/layout/src/rt-animations.ts", "symbol": null, "use": "port" },
         { "file": "packages/layout/src/rt-keyframes.ts", "symbol": "groupFromRule", "use": "port" },
         { "file": "packages/layout/src/rt-keyframes.ts", "symbol": "sampleKeyframeEffect", "use": "port" },
@@ -501,6 +502,7 @@
         { "lines": "6031-6033", "symbol": "ConsumeGenericFamily", "source": "located" }
       ],
       "dragon": [
+        { "file": "packages/dragon/src/css/aliases.ts", "symbol": null, "use": "reference" },
         { "file": "packages/dragon/src/css/grid-values.ts", "symbol": null, "use": "port" },
         { "file": "packages/dragon/src/css/math.ts", "symbol": "MathGrammar", "use": "port" },
         { "file": "packages/dragon/src/fonts/family-list.ts", "symbol": null, "use": "port" },

packages/dragon/src/analysis/animations.ts

@@ -7,6 +7,7 @@
 import { authored, diagnostic } from '../diagnostics/catalogue.ts';
 import type { KeyframesRule } from '../css/at-rules/keyframes.ts';
 import type { AnimationKind } from '../css/animation-kinds.ts';
+import { resolveAlias } from '../css/aliases.ts';
 import { admitted, animationKind } from '../css/animation-kinds.ts';
 import type { Longhand } from '../css/properties.ts';
 import { isLonghand, isShorthand, LONGHANDS } from '../css/properties.ts';
@@ -117,8 +118,10 @@ const easingOf = (i: AnimItem): EasingValue => (i.kind === 'easing' ? i.easing :
 const keywordOf = (i: AnimItem): string => (i.kind === 'keyword' ? i.value : i.kind === 'name' ? i.value : '');
 
 /** The longhands a transition-property name stands for (R8: shorthands expand, `all` is every Dragon longhand). */
-function longhandsNamed(name: string): readonly Longhand[] | null {
-  if (name === 'all') return LONGHANDS;
+function longhandsNamed(written: string): readonly Longhand[] | null {
+  if (written === 'all') return LONGHANDS;
+  // css_animations.cc CalculateTransitionUpdateForStandardProperty resolves an alias name to its property.
+  const name = resolveAlias(written);
   if (isLonghand(name)) return [name];
   if (isShorthand(name)) return shorthandHandler(name).longhands;
   return null;

packages/dragon/src/analysis/variables.ts

@@ -142,7 +142,7 @@ export function substituteDeclaration(d: Declaration, customs: CustomProperties)
   const invalid = pending.longhands.map(unset);
   if (text === null) return make(invalid, null, true);
   const parsed = parseSubstitutedValue(d.property as Longhand | Shorthand, text, d.valueSpan);
-  const shown = `${d.property}: ${d.text} substitutes to "${readable(text)}"`;
+  const shown = `${d.alias ?? d.property}: ${d.text} substitutes to "${readable(text)}"`;
   switch (parsed.kind) {
     case 'ok':
       // css-logical-1 §3: a declaration narrowed to one direction keeps that direction's mapping (analysis/logical.ts).

packages/dragon/src/css/aliases.ts

@@ -0,0 +1,33 @@
+// Legacy property aliases: the alias_for entries of third_party/blink/renderer/core/css/css_properties.json5 at tag 145.0.7632.6
+// (sha256 abdc48ff9bf1815acd8f01907eecb26cc788f44ecd6163dd9821521d815f71e3, lines 7995-8099, 9098-9110 and 9687-9963). Chrome
+// resolves an alias to its property at parse time, so a declaration of either is the same declaration and the later one wins in
+// the cascade. Each family's aliases live in aliases/<family>.ts, spread here one line per family, sorted by family id. An alias
+// is listed only when its property is a Dragon longhand or shorthand and Chrome parses the two alike: the aliases Chrome parses
+// with UseAliasParsing (css_parsing_utils.cc: -webkit-border-radius, -webkit-transform, -webkit-perspective,
+// -webkit-background-*, -webkit-mask-*, -webkit-appearance) wait for their property's lane, -webkit-writing-mode is a surrogate,
+// not an alias, and grid-gap, grid-row-gap and grid-column-gap are already shorthands of the grid family (properties/grid.ts).
+import type { Longhand, Shorthand } from './properties.ts';
+import { isLonghand, isShorthand } from './properties.ts';
+import { BOX_ALIASES } from './aliases/box.ts';
+import { FLEX_ALIASES } from './aliases/flex.ts';
+import { LOGICAL_ALIASES } from './aliases/logical.ts';
+
+/** Each family's aliases, one line per family, sorted by family id (test/registry-claims.test.ts). */
+export const ALIAS_FAMILIES: { readonly [family: string]: { readonly [alias: string]: Longhand | Shorthand } } = {
+  box: BOX_ALIASES,
+  flex: FLEX_ALIASES,
+  logical: LOGICAL_ALIASES,
+};
+
+const ALIASES: ReadonlyMap<string, Longhand | Shorthand> = new Map(Object.values(ALIAS_FAMILIES).flatMap((f) => Object.entries(f)));
+
+if (ALIASES.size !== Object.values(ALIAS_FAMILIES).reduce((n, f) => n + Object.keys(f).length, 0)) throw new Error('an alias belongs to two families');
+for (const [alias, property] of ALIASES) {
+  if (isLonghand(alias) || isShorthand(alias)) throw new Error(`${alias} is both an alias and a property`);
+  if (!isLonghand(property) && !isShorthand(property)) throw new Error(`${alias} aliases ${property}, which is not a Dragon property`);
+}
+
+/** The property a lower-cased property name stands for: its alias target, or the name itself. */
+export function resolveAlias(name: string): string {
+  return ALIASES.get(name) ?? name;
+}

packages/dragon/src/css/aliases/box.ts

@@ -0,0 +1,6 @@
+// The box family's legacy aliases (aliases.ts): Chrome 145 css_properties.json5 alias_for.
+import type { BOX_LONGHANDS } from '../properties/box.ts';
+
+export const BOX_ALIASES = {
+  '-webkit-box-sizing': 'box-sizing',
+} as const satisfies { readonly [alias: string]: (typeof BOX_LONGHANDS)[number] };

packages/dragon/src/css/aliases/flex.ts

@@ -0,0 +1,18 @@
+// The flex family's legacy aliases (aliases.ts): Chrome 145 css_properties.json5 alias_for.
+import type { FLEX_LONGHANDS, FLEX_SHORTHANDS } from '../properties/flex.ts';
+
+export const FLEX_ALIASES = {
+  '-webkit-align-content': 'align-content',
+  '-webkit-align-items': 'align-items',
+  '-webkit-align-self': 'align-self',
+  '-webkit-column-gap': 'column-gap',
+  '-webkit-flex': 'flex',
+  '-webkit-flex-basis': 'flex-basis',
+  '-webkit-flex-direction': 'flex-direction',
+  '-webkit-flex-flow': 'flex-flow',
+  '-webkit-flex-grow': 'flex-grow',
+  '-webkit-flex-shrink': 'flex-shrink',
+  '-webkit-flex-wrap': 'flex-wrap',
+  '-webkit-justify-content': 'justify-content',
+  '-webkit-order': 'order',
+} as const satisfies { readonly [alias: string]: (typeof FLEX_LONGHANDS)[number] | (typeof FLEX_SHORTHANDS)[number] };

packages/dragon/src/css/aliases/logical.ts

@@ -0,0 +1,36 @@
+// The logical family's legacy aliases (aliases.ts): Chrome 145 css_properties.json5 alias_for. before/after are the block
+// sides, start/end the inline sides, and logical-width/height the inline and block sizes.
+import type { LOGICAL_SHORTHANDS } from '../properties/logical.ts';
+
+export const LOGICAL_ALIASES = {
+  '-webkit-border-after': 'border-block-end',
+  '-webkit-border-after-color': 'border-block-end-color',
+  '-webkit-border-after-style': 'border-block-end-style',
+  '-webkit-border-after-width': 'border-block-end-width',
+  '-webkit-border-before': 'border-block-start',
+  '-webkit-border-before-color': 'border-block-start-color',
+  '-webkit-border-before-style': 'border-block-start-style',
+  '-webkit-border-before-width': 'border-block-start-width',
+  '-webkit-border-end': 'border-inline-end',
+  '-webkit-border-end-color': 'border-inline-end-color',
+  '-webkit-border-end-style': 'border-inline-end-style',
+  '-webkit-border-end-width': 'border-inline-end-width',
+  '-webkit-border-start': 'border-inline-start',
+  '-webkit-border-start-color': 'border-inline-start-color',
+  '-webkit-border-start-style': 'border-inline-start-style',
+  '-webkit-border-start-width': 'border-inline-start-width',
+  '-webkit-logical-height': 'block-size',
+  '-webkit-logical-width': 'inline-size',
+  '-webkit-margin-after': 'margin-block-end',
+  '-webkit-margin-before': 'margin-block-start',
+  '-webkit-margin-end': 'margin-inline-end',
+  '-webkit-margin-start': 'margin-inline-start',
+  '-webkit-max-logical-height': 'max-block-size',
+  '-webkit-max-logical-width': 'max-inline-size',
+  '-webkit-min-logical-height': 'min-block-size',
+  '-webkit-min-logical-width': 'min-inline-size',
+  '-webkit-padding-after': 'padding-block-end',
+  '-webkit-padding-before': 'padding-block-start',
+  '-webkit-padding-end': 'padding-inline-end',
+  '-webkit-padding-start': 'padding-inline-start',
+} as const satisfies { readonly [alias: string]: (typeof LOGICAL_SHORTHANDS)[number] };

packages/dragon/src/css/at-rules/keyframes.ts

@@ -7,6 +7,7 @@ import { generate } from 'css-tree';
 import { authored, diagnostic } from '../../diagnostics/catalogue.ts';
 import type { Diagnostic, Span } from '../../types.ts';
 import type { AtRuleContext, AtRuleHandler } from '../at-rules.ts';
+import { resolveAlias } from '../aliases.ts';
 import { list, spanOf } from '../ast.ts';
 import { asciiLower, decodeName } from '../escapes.ts';
 import type { Longhand } from '../properties.ts';
@@ -133,15 +134,18 @@ function parseBlock(rule: CssNode, src: KeyframesSource, name: string, diagnosti
       continue;
     }
     const written = decodeName(String(d['property']));
-    const property = written.startsWith('--') ? written : asciiLower(written);
+    const lowered = written.startsWith('--') ? written : asciiLower(written);
+    const property = resolveAlias(lowered);
+    // A legacy alias is its property (aliases.ts); its diagnostics name the alias as written too.
+    const aliasNote = (message: string): string => (property === lowered ? message : `${message} (${lowered} is an alias of ${property})`);
     const valueNode = d['value'] as CssNode;
     const valueSpan = spanOf(valueNode, src.base);
     const text = generate(valueNode);
     const source = src.text.slice(valueSpan.start - src.base.start, valueSpan.end - src.base.start);
     const refuse = (code: 'DRAGON_UNSUPPORTED_PROPERTY' | 'DRAGON_UNSUPPORTED_VALUE' | 'DRAGON_UNSUPPORTED_IMPORTANT' | 'DRAGON_CSS_INVALID_VALUE', message: string, at: Span = span): void => {
       // A property or !important refusal fixes by deleting the declaration (its catalogue fix is an edit).
       const edits = code === 'DRAGON_UNSUPPORTED_PROPERTY' || code === 'DRAGON_UNSUPPORTED_IMPORTANT' ? { edits: [{ span, replacement: '' }] } : {};
-      diagnostics.push(diagnostic(code, { origin: authored(at), message, ...edits }));
+      diagnostics.push(diagnostic(code, { origin: authored(at), message: aliasNote(message), ...edits }));
     };
     if (d['important'] !== false) {
       refuse('DRAGON_UNSUPPORTED_IMPORTANT', `!important on ${property} in @keyframes ${name}: Chrome ignores it inside @keyframes, so the declaration has no effect`);
@@ -188,7 +192,7 @@ function parseBlock(rule: CssNode, src: KeyframesSource, name: string, diagnosti
       for (const lh of parsed.longhands) values.push({ property: lh.property, value: lh.value, span, valueSpan, text });
       continue;
     }
-    if (parsed.kind === 'refused') diagnostics.push(parsed.diagnostic);
+    if (parsed.kind === 'refused') diagnostics.push({ ...parsed.diagnostic, message: aliasNote(parsed.diagnostic.message) });
     else if (parsed.kind === 'token') refuse('DRAGON_UNSUPPORTED_VALUE', `${property}: ${generate(parsed.token)} is unsupported: ${parsed.reason}`, spanOf(parsed.token, src.base));
     else if (parsed.kind === 'multi') refuse('DRAGON_UNSUPPORTED_VALUE', `multi-token value "${text}" for ${property} is not supported in milestone 1`, valueSpan);
     else refuse('DRAGON_CSS_INVALID_VALUE', parsed.reason === undefined ? `"${text}" is not a valid value for ${property}, so Chrome ignores it in @keyframes ${name}` : `"${text}" is not a valid value for ${property}: ${parsed.reason}`, valueSpan);