@microsoft/webui-framework 0.0.24 → 0.0.26

package/README.md

@@ -7,7 +7,7 @@ This package is the browser-side runtime used by `webui build --plugin=webui`. I
 - `WebUIElement` for SSR hydration and client-created elements
 - `@observable`, `@attr`, and `@volatile` decorators
 - direct DOM binding updates
-- light DOM or shadow DOM rendering (`--dom=light|shadow` flag)
+- Shadow-default components with opt-in global Light and authored Shadow islands
 - SSR state seeding
 
 If you are building WebUI apps in this repo, this is the component model used by examples like `examples/app/todo-webui`, `examples/app/commerce`, and `examples/app/contact-book-manager`.
@@ -79,7 +79,9 @@ CounterCard.define('counter-card');
 <button @click="{increment()}">Increment</button>
 ```
 
-Build with `--dom=shadow` (default) to wrap in a declarative shadow root, or `--dom=light` for light DOM rendering.
+Unwrapped components default to Shadow. A `dom: "light"` build renders them as
+Light while preserving any sole top-level
+`<template shadowrootmode="open">` component as Shadow.
 
 ### Use it from your page
 
@@ -128,10 +130,9 @@ rendered block size of one instance; WebUI emits it as
 `contain-intrinsic-block-size: auto 18rem` before first layout. The SSR DOM
 remains present, searchable, and accessible while the browser skips offscreen
 style, layout, and paint work. The generated policy applies to instances in the
-document, Light DOM, and standard Shadow DOM components. A `--dom=light`
-component inside an authored shadow root needs the `style` CSS strategy or an
-equivalent rule in that root's stylesheet because document styles cannot cross
-the boundary.
+document, Light DOM, and standard Shadow DOM components. A Light component
+inside a Shadow root receives the rule through its precomputed style
+closure, which delivers the stylesheet into that root under every CSS strategy.
 
 Import the optional coordinator entry once before component modules:
 
@@ -165,6 +166,52 @@ If the optional entry or `IntersectionObserver` is unavailable, hydration falls
 back to eager; `content-visibility` remains browser-managed. See
 [Lazy Hydration](https://microsoft.github.io/webui/guide/concepts/hydration#lazy-hydration).
 
+Router applications should author `<template w-hydrate="interaction">` and use
+the framework-agnostic `@microsoft/webui-router/preload.js` handle. FAST and
+other hydration runtimes use that same handle with their own readiness signal.
+Non-router apps use the lower-level framework entry:
+
+```ts
+import {
+  installInteractionHydration,
+  isInteractionReplay,
+} from
+  '@microsoft/webui-framework/interaction-hydration.js';
+
+installInteractionHydration({
+  load: () => import('./components.js'),
+});
+```
+
+Pointer-down, focus, and keyboard intent starts `load()` without cancellation.
+An unmodified primary click waits and replays on its original composed-path
+target; `load()` must resolve only after listeners are ready. Hover, modified
+clicks, and previously cancelled clicks do not replay. Use
+`isInteractionReplay(event)` to deduplicate ancestor capture work.
+
+This opt-in trades first-interaction latency for lower startup JS and heap.
+Prefer an eager root with lazy descendants when request-to-hydrated time matters.
+Synthetic replay cannot preserve transient user activation or target controls
+inside closed shadow roots; hydrate those paths eagerly.
+
+One offscreen singleton boundary can retain browser rendering deferral while
+also deferring its module graph:
+
+```html
+<template
+  w-render="lazy"
+  w-reserve-block-size="18rem"
+  w-hydrate="interaction"
+>
+  <!-- Component content -->
+</template>
+```
+
+Do not use the combined form for repeated items. A visible app root gains no
+rendering benefit from `content-visibility`; keep interaction on that root and
+put `w-render="lazy"` on offscreen descendants.
+
+
 ### Build with the WebUI plugin
 
 ```bash
@@ -199,12 +246,35 @@ authored `<boundary>` directives through
 `@microsoft/webui-framework` entry has no dependency on the coordinator, so
 normal applications pay no streaming bundle or initialization cost.
 
-Each committed boundary receives its own ephemeral state object directly during
+Boundaries may be authored in entries and reusable components, including
+runtime conditions, outlets, and selected routes. A boundary-bearing subtree
+reached from a `<for>` body fails the build with `boundary-in-repeat`. A whole
+`<for>` may sit inside one boundary, and boundaries before or after a `<for>`
+are valid. A component-local boundary uses a generated parent span, so an early
+compiler-marked child can hydrate before the opaque parent tail in light or
+shadow DOM. The server's boundary-only `resume` emits that checkpoint first;
+`advance` emits the following parent tail, with no sibling boundary workaround.
+Authored boundaries cannot nest.
+
+Span resolution is entirely coordinator-owned: the generated `data-ws-span` and
+`data-ws-enclosing` attributes, and the open-span registry that pairs them, live
+only in the opt-in streaming entry. It resolves the one ancestor an entitled
+early child may skip and passes that element to the activation hook, which
+compares it by identity. The always-shipped entry therefore carries no span
+attribute name and no span bookkeeping at all.
+
+Each runtime occurrence receives an ephemeral state object directly during
 activation. The coordinator does not publish that state to
-`window.__webui.state`, and it removes generated checkpoint scaffolding after
-commit. Every commit also emits a `performance.mark()` — `webui:boundary:<id>`,
-`webui:boundary:<id>:update`, or `webui:streaming:terminal` — which needs no
-flag and no listener, so tooling that loads after hydration can still read it.
+`window.__webui.state`, and it removes generated checkpoint and span
+scaffolding after commit. Updates apply state to retained roots and never insert
+markup or rerun hydration.
+
+The browser reads version-2
+`[2, sequence, kind, target, payload]` records for final checkpoints,
+updatable checkpoints, updates, span completions, and terminal. Every commit
+also emits a `performance.mark()` - `webui:boundary:<id>`,
+`webui:boundary:<id>:update`, `webui:span:<id>`, or
+`webui:streaming:terminal` - which needs no flag or listener.
 Set `window.__WEBUI_STREAMING_DEBUG__ = true` only when tooling needs the live
 `webui:boundary-hydrated` event as well.
 
@@ -240,9 +310,14 @@ development-only and is dead-code-eliminated from production bundles via the
 
 Override the protected `hydratedCallback()` hook for work that requires the
 component's bindings, events, and `w-ref` references to be ready. It runs
-synchronously exactly once after the first successful ordinary SSR hydration,
-client-created mount, lazy activation, deferred streamed activation, or dormant
-static-host wake. Its once-latch is set before author code runs, so a thrown
+exactly once with the first successful ordinary SSR hydration, client-created
+mount, lazy activation, deferred streamed activation, or dormant static-host
+wake. If CSP blocks the temporary Link-mode prepaint guard, a client-created
+mount keeps non-style content detached and delays `$ready` and this callback
+until its native links load and the content is appended. Reactive writes made
+while detached are reconciled immediately before append. A synchronous
+disconnect/reconnect preserves the pending mount; a lasting disconnect cancels
+it. The callback's once-latch is set before author code runs, so a thrown
 callback is not retried on reconnect.
 
 `connectedCallback()` remains a native per-connection lifecycle. On ordinary
@@ -253,22 +328,29 @@ post-hydration signal. Descendants must not structurally mutate a containing
 component's SSR subtree before it hydrates, because hydration relies on stable
 compiled paths.
 
-### DOM strategy (`--dom`)
-
-The `--dom` flag controls how the server renders component content:
+### Light and Shadow DOM
 
-| Flag | Behavior |
-|------|----------|
-| `--dom=shadow` (default) | Wraps component HTML in `<template shadowrootmode="open">` |
-| `--dom=light` | Renders component content as direct children of the host element |
+An unwrapped component receives a generated open Shadow root by default. In a
+`dom: "light"` build it renders as direct children of its host. A component
+whose sole top-level element is a bare `<template>` explicitly renders as Light
+and is unwrapped, even under the Shadow fallback. A sole
+`<template shadowrootmode="open">` remains Shadow in either mode. Templates with
+attributes and policy wrappers do not select a mode. Closed roots and invalid
+values or placement are build errors; `<slot>` is rejected only for effective
+Light components.
 
 The runtime auto-detects which mode was used at hydration time:
 - If a `shadowRoot` already exists → shadow DOM SSR path
 - If `childNodes` exist but no shadow root → light DOM SSR path
 - If neither → client-created path (uses `meta.sd` to decide)
 
-Light DOM is useful for simpler styling (CSS inheritance works naturally) and
-better search-engine indexing.  Shadow DOM provides style encapsulation.
+Light components use authored/global ordinary CSS in the owning CSS tree.
+Shadow components keep native Shadow scoping. `:host`, `:host-context`, and
+`::slotted` fail in effective Light CSS.
+The Link, Style, and Module delivery strategies all support both modes.
+
+In a Light build, add open wrappers to slot, native-encapsulation, or CSS-heavy
+frequently restyled components.
 
 ---
 
@@ -318,15 +400,38 @@ The asset graph keeps entry-owned templates external, leaves single-root
 dependencies inline, and emits dependencies shared by multiple roots once as
 flat dynamic chunks. Component assets cannot be combined with `<route>`. Load
 the normal entry bundle first so external prerequisites are registered.
-
-Shared chunk filenames are generated and must not be copied into the manifest.
-Each root asset carries its own dynamic imports; `--metafile` is available for
-analysis and build tooling. `preload(tag)` starts template, module, and optional
-data work. Concurrent roots share in-flight chunk imports by resolved URL and
-CSS module styles are deduped. `create(tag)` creates the element after
-template/module work is ready and does not block on optional data by default. Use
-`create(tag, { awaitData: true, dataTimeoutMs: 150 })` only when a component must
-wait briefly for state before mounting.
+Current assets require version 3 and an atomically validated
+`componentStyles` catalog; any other version is rejected as unsupported.
+
+The compiler records final Link stylesheet filenames in the protocol. For
+Shadow builds, the handler emits that finite manifest as inert JSON in the
+document head; body-only host protocols emit it at the start of their rendered
+body fragment. Light builds emit the same hrefs as deduplicated document
+stylesheets because their CSS must apply globally.
+Automatic Shadow intent preloading therefore requires HTML rendered through the
+WebUI handler or `Protocol`, which emits `#webui-component-assets`. A shell that
+uses build artifacts without rendering the protocol still mounts safely through
+the native stylesheet guard, but it does not receive the earlier
+compiler-owned style preload.
+Shared chunk and content-hashed stylesheet filenames are generated and must not
+be copied into authored code. Each root asset carries its own dynamic imports;
+`--metafile` remains available for analysis and build tooling.
+
+In Shadow builds, `preload(tag)` reads the compiler-owned style metadata and
+starts Link styles beside the authored root asset, component module, and
+optional data request. Only the stable root asset URL remains in application
+code; shared chunks and content-hashed CSS stay compiler-owned.
+
+Bundler-generated loaders can use `asset: () => import('./settings-dialog.webui.js')`
+instead of a URL. This keeps chunk naming and public-path rewriting inside the
+bundler while preserving the same `preload(tag)` and `create(tag)` lifecycle.
+Concurrent roots share in-flight chunk and stylesheet work. `create(tag)`
+creates the element after template/module work is ready and does not block on
+optional data by default. Use
+`create(tag, { awaitData: true, dataTimeoutMs: 150 })` only when a component
+must wait briefly for state before mounting. A rejected root asset or authored
+module is evicted from the registry so a later `preload(tag)` or `create(tag)`
+retries it.
 
 ### `@observable`
 
@@ -445,10 +550,11 @@ resource-constrained devices.
    `$update(path)` only visits bindings that reference the changed property.
    Everything else is skipped via a per-path index built once at hydration time.
 
-2. **Zero allocations during updates.**
+2. **Zero framework allocations during ordinary updates.**
    Targeted updates are a single `Map.get()` → direct array iteration.
    No intermediate arrays, no object creation, no spread operators on the
-   update path.
+   update path. A changed raw HTML binding necessarily parses and creates its
+   replacement DOM nodes inside its pre-resolved ownership range.
 
 3. **Parse once, clone forever.**
    Compiled template HTML is parsed via `innerHTML` once per component tag
@@ -527,9 +633,8 @@ is driven by data (template metadata + state values), not code.  Any language
 that can read the compiled metadata and produce HTML can serve as the SSR
 backend.  No comment markers or data attributes are needed — the runtime
 resolves ordinary buffered SSR nodes via the lockstep hydration walk.
-Progressive streaming uses temporary checkpoint scaffolding only to delay
-activation until a complete region arrives; it removes that scaffolding after
-commit.
+Progressive streaming uses temporary checkpoint and generated-span scaffolding
+to activate complete runtime regions; it removes that scaffolding after commit.
 
 ### Build → Serve → Hydrate → Update
 
@@ -664,7 +769,6 @@ interface TemplateMeta {
   r?: [collection, itemVar, blockIdx, slot][]; // Repeat blocks
   eg?: [event, [[handler, argSpecs, targetIndex, usesEvent?]]][]; // Events
   b?: TemplateBlockMeta[];             // Nested block metadata
-  sa?: string;                         // Adopted stylesheet specifier
   sd?: 1;                              // Shadow DOM flag for client-created
   re?: [event, handler, argSpecs][];    // Root-level events
   tr?: string[];                       // Template state roots
@@ -770,7 +874,13 @@ State seeding uses `window.__webui.state` loaded from the server-emitted
 `@observable` and `@attr` keys from reachable authored components select
 initial state; HTML-only dormant components and authored template-only roots
 contribute no startup keys. Without projection metadata, the server preserves
-full state. During `$mount()`, `$applySSRState()` writes matching decorated keys
+full state. The startup state is not a permanent application store. Eager
+components consume it during hydration, lazy components copy their projected
+roots before deferral, and the framework releases the global handoff when
+`webui:hydration-complete` fires on a page without a route chain. Routed pages
+retain it for router-owned lazy startup. Normalized template closure entries are
+released as soon as their functions are embedded in template metadata. During
+`$mount()`, `$applySSRState()` writes matching decorated keys
 directly to observable backing fields before any bindings are wired:
 
 ```mermaid
@@ -829,10 +939,50 @@ The framework supports three CSS delivery strategies:
 
 | Strategy | How it works |
 |----------|-------------|
-| **Link** | `<link>` tag baked into `meta.h` — loaded by the browser naturally |
-| **Inline** | `<style>` tag baked into `meta.h` — no external request |
+| **Link** | `<link>` tag baked into `meta.h`; the first client-created shadow instance authorizes shared constructable sheets through native loading, then warm instances adopt them before paint |
+| **Style** | `<style>` tag baked into `meta.h` — no external request |
 | **Module** | `<script type="importmap">{"imports":{"tag-name":"data:text/css,..."}}</script>` in the HTML payload registers the CSS as a module under `tag-name`. The framework imports it via `import(tag, { with: { type: 'css' } })` and applies the resulting `CSSStyleSheet` via `adoptedStyleSheets` for shadow DOM isolation |
 
+Link promotion is progressive enhancement. Registration performs a bounded
+`<link rel="preload" as="style">` using the stylesheet's CORS, integrity, and
+referrer-policy attributes, so the native stylesheet link can reuse the same
+style-destination request. Preload bytes are never applied directly, and a
+preload cannot inspect response MIME type; the first client instance's native
+link remains authoritative for CSP, MIME, integrity, CORS, redirects, and
+service workers. The framework releases the instance's paint guard as soon as
+every original link loads, before constructing the shared ordered set from
+native CSSOM. It then adopts that set before existing sheets with one assignment
+and shares it with later instances. Promoted links remain disabled in place so
+reconnect hydration retains the compiled element indexes. Classes with an authored
+`hydratedCallback()` still take the guarded native path on warm mounts, allowing
+lifecycle-added `<style>` elements to preserve native cascade order. If
+construction is unsupported, native CSSOM or
+unredirected, non-service-worker timing is unavailable, or `@import`, unsafe URL
+syntax, link attributes, bindings, compiled events, or authored DOM `<style>`
+cascade semantics cannot be preserved, the original links remain. An anonymous
+first-layer shadow guard prevents component CSS from overriding the loading
+gate and cancels host transitions before hiding. When CSP blocks that guard,
+non-style content, `$ready`, and `hydratedCallback()` remain deferred; current
+reactive state is reconciled before append. If that reconciliation changes a
+request-affecting bound link value, the framework waits for the replacement
+native load before append. Disconnecting permanently cancels
+the pending mount, while a synchronous reconnect preserves it. A link error
+is reported, leaves the browser's native links in place, releases the temporary
+guard, and completes deferred hydration. The component may be unstyled after a
+definitive stylesheet failure, but it remains visible and usable. SSR hydration,
+Style, Module, and authored/global Light DOM behavior are unchanged.
+
+### Intent-time Link preloading for component assets
+
+In a Shadow build, call `assets.preload(tag)` from pointer, focus, or other
+intent handling. The framework reads the compiler-owned head manifest, so
+application code never derives or hardcodes content-hashed CSS names. Link
+styles begin before the root asset executes, and later template registration
+reuses the same style-destination request. Repeated intent is deduplicated. An
+intent that never mounts the component may still produce the browser's standard
+unused-preload warning. Light builds load component-asset CSS as document
+stylesheets at the structural head boundary instead.
+
 CSS module stylesheets are cached so each component instance adopts the same
 parsed sheet without re-parsing CSS.  The `meta.sa` field specifies the
 stylesheet specifier for a component.
@@ -843,7 +993,8 @@ stylesheet specifier for a component.
 
 Unlike frameworks that use comment markers or data attributes to locate each
 dynamic binding, this framework uses **compiled element indices** — each
-binding names its element by pre-order position within its compiled section. Progressive streaming's temporary boundary markers locate complete
+binding names its element by pre-order position within its compiled section.
+Progressive streaming's temporary boundary and span markers locate complete
 activation regions, not individual bindings.
 
 ### Client-created resolution (`collectTemplateElements`)
@@ -862,24 +1013,28 @@ const target = elements[index];
 ### SSR resolution (`buildSSRIndex`)
 
 SSR DOM differs from the compiled template: the renderer strips inter-element
-whitespace, and `<if>` / `<for>` bodies are rendered inline between markers.
+whitespace, `<if>` / `<for>` bodies are rendered inline between structural
+markers, and raw HTML values can contribute arbitrary element runs.
 `buildSSRIndex` walks the SSR DOM and the compiled template DOM **in lockstep**,
 skipping whole marker ranges, and numbers the result the same way:
 
 ```typescript
 // Elements are paired positionally and numbered in pre-order.
-// Structural ranges are skipped whole — that content belongs to
-// the block's own metadata.
+// Structural and raw HTML ranges are skipped whole - that content
+// is not part of the enclosing section's static element numbering.
 // Text is the exception: whitespace stripping means text nodes do
-// not line up, so text slots still resolve by ordinal.
+// not line up, so each text slot resolves from its compiled
+// right-hand static or marker boundary.
 ```
 
-This eliminates all *per-binding* annotation: no `data-w-*` attributes, no
-comment per text run, no DOM markers around individual bindings.  What the SSR
-server does emit is the five structural comments documented above
-(`<!--wr-->`, `<!--wi-->`, `<!--/wr-->`, `<!--wc-->`, `<!--/wc-->`), which
-delimit `<if>` / `<for>` bodies and are what the walk skips over and anchors
-blocks on.  They are removed once hydration completes.
+This eliminates annotations for ordinary bindings: no `data-w-*` attributes and
+no comments around escaped text. The SSR server emits five structural comments
+for `<if>` / `<for>` bodies plus paired `<!--wN-->` / `<!--/wN-->` markers around each raw HTML
+binding. Structural closing/item markers are removed after hydration. Raw HTML
+anchors remain so updates can replace zero or multiple direct sibling nodes
+without touching content outside the binding's range. These exact marker
+comments are framework-reserved and must not appear in the trusted raw value
+inside that range.
 
 ---
 
@@ -897,7 +1052,8 @@ blocks on.  They are removed once hydration completes.
 
 - **No virtual DOM** — no tree copy, no diff algorithm
 - **No runtime template parsing** — the Rust compiler handles all syntax
-- **No `innerHTML` on updates** — only `textContent` and `setAttribute`
+- **No parent-wide `innerHTML` on updates** — raw HTML parses into its bounded
+  contextual range; escaped text and attributes patch direct node references
 - **No `querySelector` on updates** — all nodes are pre-resolved references
 - **No recursion in hot paths** — conditions use iterative stack evaluation
 

package/dist/component-asset/asset.d.ts

@@ -1,4 +1,5 @@
 import type { CompiledConditionFn, TemplateMeta } from '../template.js';
+import { type ComponentStyles } from '../element/styles.js';
 export interface ComponentAssetImport {
     components: string[];
     href: string;
@@ -6,17 +7,18 @@ export interface ComponentAssetImport {
 }
 export interface ComponentAsset {
     type: 'webui-component-asset';
-    version: 2;
+    version: 3;
     kind: 'root' | 'chunk';
     root?: string;
     components: string[];
     requiredComponents: string[];
     externalComponents: string[];
     imports: ComponentAssetImport[];
-    templateStyles: string[];
+    componentStyles: ComponentStyles;
     templates: Record<string, TemplateMeta>;
     templateFunctions?: Record<string, CompiledConditionFn[]>;
 }
+export declare function prepareAssetComponentStyles(value: unknown): ComponentStyles;
 export declare function readComponentAssetModule(module: unknown): unknown;
 export declare function validateAsset(value: unknown, expectedKind: ComponentAsset['kind']): asserts value is ComponentAsset;
 export declare function sameComponents(left: readonly string[], right: readonly string[]): boolean;

package/dist/component-asset/asset.js

@@ -1,5 +1,18 @@
+import { requireComponentStyles, } from '../element/styles.js';
 const ASSET_TYPE = 'webui-component-asset';
-const ASSET_VERSION = 2;
+const COMPONENT_STYLES_ASSET_VERSION = 3;
+const preparedAssetStyles = new WeakMap();
+export function prepareAssetComponentStyles(value) {
+    if (typeof value === 'object' && value !== null) {
+        const cached = preparedAssetStyles.get(value);
+        if (cached)
+            return cached;
+        const prepared = requireComponentStyles(value);
+        preparedAssetStyles.set(value, prepared);
+        return prepared;
+    }
+    return requireComponentStyles(value);
+}
 export function readComponentAssetModule(module) {
     if (!isObject(module) || !isObject(module.default)) {
         throw new Error('[WebUI] Component asset module must default-export an asset object.');
@@ -14,9 +27,12 @@ export function validateAsset(value, expectedKind) {
     if (asset.type !== ASSET_TYPE) {
         throw new Error(`[WebUI] Invalid component asset type: ${String(asset.type)}`);
     }
-    if (asset.version !== ASSET_VERSION) {
+    if (asset.version !== COMPONENT_STYLES_ASSET_VERSION) {
         throw new Error(`[WebUI] Unsupported component asset version: ${String(asset.version)}`);
     }
+    if (asset.componentStyles === undefined) {
+        throw new Error('[WebUI] Version 3 component assets require componentStyles.');
+    }
     if (asset.kind !== expectedKind) {
         throw new Error(`[WebUI] Expected component asset kind "${expectedKind}", received "${String(asset.kind)}".`);
     }
@@ -26,7 +42,7 @@ export function validateAsset(value, expectedKind) {
     if (!Array.isArray(asset.imports)) {
         throw new Error('[WebUI] Component asset imports must be an array.');
     }
-    validateStringArray(asset.templateStyles, 'templateStyles');
+    prepareAssetComponentStyles(asset.componentStyles);
     if (!isObject(asset.templates)) {
         throw new Error('[WebUI] Component asset templates must be an object.');
     }

package/dist/component-asset/generated-manifest.d.ts

@@ -0,0 +1 @@
+export declare function takeGeneratedComponentAssetStyles(tag: string): readonly string[] | undefined;

package/dist/component-asset/generated-manifest.js

@@ -0,0 +1,32 @@
+const COMPONENT_ASSET_MANIFEST_ID = 'webui-component-assets';
+let manifestLoaded = false;
+export function takeGeneratedComponentAssetStyles(tag) {
+    if (typeof window !== 'object' || typeof document !== 'object')
+        return undefined;
+    const existing = window.__webui?.componentAssetStyles;
+    if (existing) {
+        const styles = existing[tag];
+        if (styles)
+            delete existing[tag];
+        return styles;
+    }
+    if (manifestLoaded)
+        return undefined;
+    const element = document.getElementById(COMPONENT_ASSET_MANIFEST_ID);
+    if (!element) {
+        manifestLoaded = true;
+        return undefined;
+    }
+    const text = element.textContent;
+    element.remove();
+    const manifest = text
+        ? JSON.parse(text)
+        : {};
+    const runtime = window.__webui ?? (window.__webui = {});
+    runtime.componentAssetStyles = manifest;
+    manifestLoaded = true;
+    const styles = manifest[tag];
+    if (styles)
+        delete manifest[tag];
+    return styles;
+}

package/dist/component-asset/loader.d.ts

@@ -1 +1,2 @@
-export declare function loadComponentAsset(tag: string, url: string | URL): Promise<void>;
+import type { ComponentAssetSource } from './manifest.js';
+export declare function loadComponentAsset(tag: string, source: ComponentAssetSource): Promise<void>;