@lightspeed-js/core 0.1.0

package/dist/types/build.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="./src/types/virtual.d.ts" />
+/// <reference path="./src/types/optional.d.ts" />
+/// <reference path="./src/types/lsp.d.ts" />
+export { createLightspeedApp, LightspeedRuntime } from "./src/runtime/core.js";
+export { registerPageExpressions } from "./src/runtime/core.js";
+export { reactive, defineSignal, onMounted, onUnmounted, defineProps, shared, } from "./src/runtime/helpers.js";
+export type { ComponentDefinition } from "./src/runtime/components/index.js";
+export type { SignalAPI } from "./src/runtime/signals/index.js";

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

@@ -0,0 +1,175 @@
+import type { ComponentDefinition } from "../runtime/components/index.js";
+/**
+ * The build agent: rebuilds a site when its content changes.
+ *
+ * It exists because **incremental rebuilds need persistent state**. A CI job
+ * starts from a clean checkout every time, so it can only ever do a full
+ * build. The agent keeps the previous `dist` and manifest between runs, which
+ * is what lets a changed entry re-render one page instead of a thousand.
+ *
+ * It runs *in the site's repo*, because rebuilding needs the site's own
+ * components and toolchain - and it holds a repo checkout but never database
+ * credentials, which is the boundary the whole architecture is drawn around.
+ */
+export interface RebuildRequest {
+    /**
+     * Build-time cell keys whose content changed - the CMS's publish payload.
+     *
+     * Each is passed to `rebuildPages` separately, so only the pages that read
+     * it are re-rendered. Empty means "rebuild everything with build-time
+     * content", which is the honest fallback when a caller does not know.
+     */
+    cells?: string[];
+    /** Where the site lives. */
+    root: string;
+    /** Build output, relative to root. */
+    dist?: string;
+    /** Pull before rebuilding. Off for tests. */
+    pull?: boolean;
+    /**
+     * A separate content checkout to build against.
+     *
+     * Content and code want different version control: code branches and merges,
+     * content is a single moving line owned by the CMS. Keeping them in one repo
+     * forces content to follow code's branching model, which means resolving
+     * content conflicts by hand when a feature branch merges.
+     *
+     * The agent joins them rather than git doing it - no submodules, no pointer
+     * commits, and each history stays clean. A path rather than a repo URL, so
+     * the source can later be a sync target or an API dump without this
+     * changing.
+     */
+    content?: string;
+    /** Commit and push the rebuilt output. */
+    push?: boolean;
+}
+export interface RebuildReport {
+    /** Output paths re-rendered, in order. */
+    rebuilt: string[];
+    /** Pages considered and skipped, with why. */
+    skipped: Array<{
+        page: string;
+        reason: string;
+    }>;
+    cells: string[];
+    pushed: boolean;
+}
+/** Drop the cache, for a caller that knows the source moved. */
+export declare function forgetDefinitions(): void;
+/** Compile every `.lsp` under the site's source directory. */
+export declare function siteDefinitions(root: string, dir?: string): Promise<ComponentDefinition[]>;
+/**
+ * Rebuild what the given content keys affect.
+ *
+ * One `rebuildPages` call per key rather than one for everything: the manifest
+ * records which cells each *output* read, so a per-entry key resolves to a
+ * single page. Passing them together would lose that precision.
+ */
+export declare function rebuild(request: RebuildRequest): Promise<RebuildReport>;
+/**
+ * Verify a webhook before doing any work.
+ *
+ * A shared secret compared in constant time. The agent is never public, but
+ * "never public" is a deployment claim rather than a property, and this is the
+ * one endpoint that can make it push to a repo.
+ */
+export declare function authorised(header: string | null, secret: string): boolean;
+/**
+ * The rebuild keys a commit message records.
+ *
+ * The CMS writes them into the commit body when it publishes, so **the commit
+ * is the record and a webhook is only a nudge**. A missed or duplicated
+ * webhook then costs nothing: the work is still described in git, and the
+ * agent finds it on the next wake.
+ *
+ * The alternative - the webhook carrying the payload - makes delivery
+ * critical. Lose one and the site is silently stale with nothing recording
+ * that a rebuild was owed.
+ */
+export declare function cellsFromCommits(log: string): string[];
+export interface Pending {
+    /** Commit the site is at now. */
+    head: string;
+    /** Keys to rebuild. Empty means nothing to do. */
+    cells: string[];
+    /** No recorded state: everything with build-time content is stale. */
+    full: boolean;
+    /** Whether the range changed content, source, or nothing. */
+    kind: ChangeKind;
+    /** Dependencies moved, so a build needs an install first. */
+    install: boolean;
+    /** Commit the content repo is at, when it is separate. */
+    contentHead?: string;
+}
+/**
+ * What has happened since the agent last built.
+ *
+ * Reads every commit between the recorded state and `HEAD`, so a run that
+ * covers three missed publishes rebuilds the union of their keys rather than
+ * only the newest.
+ */
+export declare function pendingWork(root: string, content?: string): Promise<Pending>;
+export interface AgentState {
+    /** Last site commit built. */
+    lastCommit: string | null;
+    /** Last content commit built, when content is a separate repo. */
+    lastContentCommit?: string | null;
+}
+export declare function readState(root: string): Promise<AgentState>;
+export declare function writeState(root: string, commit: string, contentCommit?: string | null): Promise<void>;
+/** What a range of commits requires. */
+export type ChangeKind = "none" | "content" | "source";
+/**
+ * Decide from the changed paths what kind of rebuild is owed.
+ *
+ * The two are not interchangeable. `rebuildPages` deliberately skips the
+ * bundler and re-renders page shells that already carry hashed asset tags -
+ * exactly right for content, and **wrong for a component change**, which
+ * produces new bundles the shells do not reference. Doing the cheap thing
+ * after a source change yields fresh HTML pointing at stale JavaScript, which
+ * looks like it worked.
+ *
+ * Deciding here rather than at the trigger means a developer push, a CMS
+ * publish and a manual run all reach the right answer without anyone choosing
+ * a mode - and without the CMS needing any part in deploying source.
+ */
+export declare function classifyChange(files: string[]): ChangeKind;
+/** Whether dependencies moved, and a build needs an install first. */
+export declare function needsInstall(files: string[]): boolean;
+/** Paths touched between the recorded state and HEAD. */
+export declare function changedFiles(root: string, from: string, to: string): Promise<string[]>;
+/**
+ * Run the site's own build.
+ *
+ * `bun run build` rather than a hardcoded `vite build`: the site owns its
+ * toolchain, and the agent is that site building itself.
+ */
+export declare function fullBuild(root: string, install: boolean, content?: string): Promise<void>;
+export interface PreviewRequest {
+    /** The cell holding this entry's content, e.g. `cms:exhibitions:my-show`. */
+    entryCell: string;
+    /** The cell the route enumerates from, e.g. `cms:exhibitions`. */
+    indexCell: string;
+    /** The entry's slug, which decides its URL. */
+    slug: string;
+    /** The content to render - the editor's current values, saved or not. */
+    data: Record<string, unknown>;
+}
+/**
+ * Render a page with unpublished content, without publishing it.
+ *
+ * The CMS sends the content **in the request**, so the agent still never talks
+ * to a database - the boundary the whole architecture rests on holds even for
+ * previewing drafts.
+ *
+ * Deliberately the same `renderPage` the build uses. A preview rendered by any
+ * other path would drift from what publishing actually produces, and a preview
+ * that lies is worse than no preview.
+ */
+export declare function preview(request: PreviewRequest & {
+    root: string;
+    dist?: string;
+}): Promise<{
+    html: string;
+    path: string;
+}>;

package/dist/types/src/cli/commands/agent.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "../types/index.js";
+/**
+ * Run the build agent.
+ *
+ * Not a library call but a process, which is why it is a CLI command rather
+ * than an export: it holds a repo checkout and the previous build between
+ * runs, and that persistence is the whole reason it exists.
+ */
+export declare const agentCommand: Command;

package/dist/types/src/cli/commands/build.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../types/index.js";
+export declare const buildCommand: Command;

package/dist/types/src/cli/commands/create.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../types/index.js";
+export declare const createCommand: Command;

package/dist/types/src/cli/commands/dev.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "../types/index.js";
+export declare const devCommand: Command;

package/dist/types/src/cli/commands/index.d.ts

@@ -0,0 +1,3 @@
+export { buildCommand } from "./build.js";
+export { createCommand } from "./create.js";
+export { devCommand } from "./dev.js";

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

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/types/src/cli/types/commands.d.ts

@@ -0,0 +1,11 @@
+export interface CommandConfig {
+    name: string;
+    description: string;
+    usage?: string;
+    examples?: string[];
+}
+export interface Command {
+    config: CommandConfig;
+    enabled?: boolean;
+    handler: (args: string[]) => void;
+}

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

@@ -0,0 +1 @@
+export * from "./commands.js";

package/dist/types/src/cli/utils/commands.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "../types/index.js";
+/**
+ * Auto-discover and register commands from the commands directory
+ */
+export declare function loadCommands(commandsDir: string): Promise<Record<string, Command>>;

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

@@ -0,0 +1 @@
+export { loadCommands } from "./commands.js";

package/dist/types/src/compile/expressions.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Every expression a template evaluates, with the scope it evaluates in.
+ *
+ * The runtime compiles these with `new Function` today, which is why a page
+ * needs a CSP with `unsafe-eval`. Compiling them at build instead needs one
+ * thing the flat extractor in `parser/template.ts` cannot give: **the loop
+ * aliases in scope at each expression**, because `item` in `{{ item.name }}`
+ * is a parameter of the compiled function, not a free variable.
+ *
+ * Those aliases are static - they come from `$for="item in items"` in the
+ * markup - so the build can know them exactly.
+ *
+ * The key format matches `BindingEvaluator`'s compile cache deliberately, so
+ * the runtime can look a compiled function up by the same key it would have
+ * cached it under. That keeps expression *source* in the DOM, which is what
+ * adoption re-binds from - so nothing about the emitted markup changes.
+ */
+export interface TemplateExpression {
+    /** The expression source, exactly as the DOM carries it. */
+    expr: string;
+    /** Loop aliases in scope, outermost first. */
+    params: string[];
+    /** Which binding produced it, for diagnostics. */
+    kind: string;
+    /** True for `$model`, which also needs a writer. */
+    writable: boolean;
+}
+/** Matches `BindingEvaluator`'s compile cache key. */
+export declare function expressionKey(expr: string, params: string[]): string;
+/** `item in items` → alias and the iterable expression. */
+export declare function parseForExpression(value: string): {
+    alias?: string;
+    items: string;
+};
+export interface ExtractOptions {
+    /**
+     * The component's handler names, in declaration order.
+     *
+     * An **expression** event handler - `@click="toggle(item)"` rather than
+     * `@click="toggle"` - is compiled with the component's handlers as
+     * parameters, so it can call them. The order matches the order `setup`
+     * registers them, which is the order they are declared.
+     */
+    handlers?: string[];
+}
+export declare function extractExpressions(template: string, options?: ExtractOptions): TemplateExpression[];
+/**
+ * The expression table a component ships.
+ *
+ * Keyed the way `BindingEvaluator` keys its compile cache, so the runtime can
+ * look up what it would otherwise have compiled. A `$model` binding also emits
+ * a writer under the same key.
+ *
+ * The table is global at runtime rather than per component: a compiled
+ * expression depends only on its source and its scope, so two components
+ * sharing an expression share a function, and merging tables cannot conflict.
+ */
+export declare function expressionTableSource(found: TemplateExpression[]): string;
+/** The same table, built as real functions - for the build and for tests. */
+export declare function buildExpressionTable(found: TemplateExpression[]): {
+    expressions: Record<string, Function>;
+    writers: Record<string, Function>;
+};
+/**
+ * Handlers a template binds that its logic never declares.
+ *
+ * `@click="publish"` compiles to a direct handler lookup, so a name that was
+ * never declared fails at *click time* with nothing wrong at build. The
+ * compiler already knows both halves - every `data-on-*` value, and every
+ * declaration - so the mismatch is detectable before anyone opens the page.
+ *
+ * Only bare names are checked. An expression handler like `remove(todo)` is
+ * compiled with the declared handlers as parameters, so an unknown name there
+ * is a different failure with a different message.
+ */
+export declare function missingHandlers(template: string, declared: string[]): string[];

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

@@ -0,0 +1,44 @@
+/**
+ * Compile a `.lsp` source into the definition the runtime mounts.
+ *
+ * The Vite plugin does this during a build, which is fine until someone wants
+ * to test a component *outside* a build - a consumer's test suite has no Vite,
+ * so without this there is no way to exercise a component at all. Tela hit this
+ * trying to test its field registry.
+ *
+ * Deliberately the same path the plugin uses rather than a parallel one: a test
+ * that compiles differently to the build is not testing the build.
+ */
+import { parseLSP } from "../parser/index.js";
+import { transformTemplate } from "../parser/template.js";
+import { scopeStyles, scopeIdFor } from "../parser/style.js";
+import type { ComponentDefinition } from "../runtime/components/index.js";
+export interface CompileSource {
+    /** Component id, normally the filename without its extension, lowercased. */
+    id: string;
+    source: string;
+}
+/**
+ * Compile a set of components together.
+ *
+ * Together, because a component's template can only be compiled once the ids of
+ * the components it mounts are known - a tag is only a component tag if
+ * something answers to that name.
+ */
+export declare function compileComponents(sources: CompileSource[], transpile?: (logic: string) => string, 
+/**
+ * Resolve a module a component's logic imports.
+ *
+ * Optional: components that import nothing need no loader. Supplied by the
+ * build and by the agent, which both have a filesystem to resolve against.
+ */
+load?: (specifier: string) => Promise<Record<string, unknown>>, 
+/**
+ * Read a `<style src="…">`, relative to the component that asked for it.
+ *
+ * Optional, like `load`: a component sharing no styles needs none. Anything
+ * with a filesystem passes `nodeStyleReader()`.
+ */
+readStyle?: (specifier: string, from: string) => string): Promise<Record<string, ComponentDefinition>>;
+export { parseLSP, transformTemplate, scopeStyles, scopeIdFor };
+export { compileLogic, buildSetup, setupSource } from "./logic.js";

package/dist/types/src/compile/logic.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Compile a component's `<logic>` into the body of a real function.
+ *
+ * Logic is currently a *string* executed with `new Function` once per
+ * instance, which is why a component cannot import anything: an `import`
+ * statement inside `new Function` is a syntax error, so the two specifiers
+ * Lightspeed understands are rewritten and the rest are dropped.
+ *
+ * Compiling it at build instead means:
+ *
+ * - **project modules import normally**, resolved and chunked by the bundler
+ * - **no `new Function` in the browser**, so a page can run under a CSP with
+ *   no `unsafe-eval` (see [[ADR-016]])
+ * - stack traces point at the `.lsp` file rather than `<anonymous>`
+ *
+ * This module only produces source. Evaluating it is the build's business, and
+ * the build may use `eval` freely - CSP constrains the browser, not the
+ * toolchain.
+ */
+export interface ImportBinding {
+    /** The module specifier. */
+    source: string;
+    /** Local name → exported name, with `default` and `*` as themselves. */
+    names: Array<{
+        local: string;
+        imported: string;
+    }>;
+    /** The original statement, for the emitted module. */
+    statement: string;
+}
+export interface CompiledLogic {
+    /** Real import statements, hoisted to module scope. */
+    imports: string[];
+    /**
+     * The same imports, decomposed.
+     *
+     * The body references these as free variables, so the client gets them from
+     * module scope while the build supplies them as function parameters - one
+     * body, two ways of binding it, and no divergence between the paths.
+     */
+    bindings: ImportBinding[];
+    /** The body of `setup(__ctx)`. */
+    body: string;
+    /** Component ids this logic imports, for the island graph. */
+    components: string[];
+}
+/** The context keys `setup` destructures. Must match `createExecutionContext`. */
+export declare const CONTEXT_KEYS: readonly ["_componentInstance", "__lightspeedRuntime", "_getComponent", "_addHandler"];
+/** `./Button.lsp` → `button` */
+export declare function componentIdFrom(path: string): string;
+export declare function compileLogic(logic: string): CompiledLogic;
+/**
+ * Top-level declarations, so the template can bind to them.
+ *
+ * Regex rather than a parser because the shapes that matter are declarations
+ * at the start of a line, and the epilogue guards every name with a `typeof`
+ * check - a name matched here that never reached scope costs nothing.
+ */
+export declare function declaredNames(logic: string): string[];
+/** The full `setup` function source, for a module or for build-time eval. */
+export declare function setupSource(compiled: CompiledLogic): string;
+/** Decompose an import statement into the names it binds. */
+export declare function parseImport(statement: string): ImportBinding;
+/**
+ * Build a runnable `setup` from logic, for the build and for tests.
+ *
+ * Uses `new Function`, which is exactly what the shipped runtime must stop
+ * doing - but a CSP governs the browser, not the toolchain. Build-time
+ * rendering and the test suite both need a callable function, and neither ends
+ * up in anyone's page.
+ */
+export declare function buildSetup(logic: string, options?: {
+    /** Transpile TypeScript before compiling, if needed. */
+    transpile?: (source: string) => string;
+    /** Resolve a specifier to a module namespace, for project imports. */
+    load?: (source: string) => Promise<Record<string, unknown>>;
+}): Promise<((ctx: Record<string, unknown>) => void) | undefined>;
+/**
+ * Declarations that are *functions*, which is what becomes a handler.
+ *
+ * The epilogue registers a name only when `typeof x === "function"`, so this
+ * has to agree with it - an event expression is compiled with the handler list
+ * as parameters, and a list that disagrees compiles the wrong signature.
+ *
+ * Statically undecidable in one case: `const f = makeHandler()` is a function
+ * at runtime and unknowable here. See the `$handlers` note in [[ADR-016]].
+ */
+export declare function declaredHandlers(logic: string): string[];
+/**
+ * The handler names an event expression is compiled with, in order.
+ *
+ * Shipped with the component so the build and the runtime cannot disagree.
+ * Reading them from the instance at runtime - `[...owner.handlers.keys()]` -
+ * makes the compiled signature depend on what happened to be registered,
+ * which is not knowable at build for `const f = makeHandler()`.
+ *
+ * Every declaration is included rather than only the ones that look like
+ * functions: a name that turns out not to be one is simply `undefined`, which
+ * costs a parameter, while a name that is missing breaks the expression.
+ */
+export declare function handlerParams(logic: string): string[];

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

@@ -0,0 +1,148 @@
+/**
+ * Where the build manifest lives.
+ *
+ * Outside `dist`, because it is build metadata rather than site output and
+ * `dist` is served publicly. Read by `rebuildPages` and by any server that has
+ * to honour a runtime-resolved route.
+ */
+export declare const MANIFEST_DIR = ".lightspeed";
+export declare const MANIFEST_FILE = "manifest.json";
+/**
+ * The one manifest file that *does* belong in `dist`.
+ *
+ * A server hosting the output has to resolve runtime routes, so it needs the
+ * route list at request time. Nothing else is serving data - page shells,
+ * skeletons and the component graph are build metadata - so only this travels
+ * with the site.
+ */
+export declare const ROUTES_FILE = "lightspeed-routes.json";
+/** Ships with every page: `$show` hides via attribute, not inline style. */
+export declare const HIDDEN_RULE = "[data-lsp-hidden]{display:none!important}";
+import type { ComponentDefinition } from "./runtime/components/index.js";
+/**
+ * What the build knows about each component, and what the page needs to load it.
+ *
+ * Deliberately keyed by **component**, not by island or by page. A component's
+ * compiled output is a function of its own source, so a page addition or a
+ * content change can never invalidate it - which is what makes incremental
+ * rebuilds possible. Rendering a page reads this; it never has to rebuild it.
+ *
+ * Internal for now. The `version` field is what makes it safe to change.
+ */
+export declare const MANIFEST_VERSION = 1;
+export interface ComponentEntry {
+    /** Chunk URL. Absent until per-component chunking exists. */
+    url?: string;
+    /** Other chunks this one needs, for precise preload hints. */
+    imports?: string[];
+    /** Critical CSS, already scoped. Content at build time; a URL once emitted. */
+    css?: string;
+    /** Deferred CSS, applied when the component hydrates. */
+    cssDeferred?: string;
+    /** Style scope hash, so a skeleton can be stamped without loading the chunk. */
+    scope?: string;
+    /**
+     * Components this one's template mounts.
+     *
+     * Distinct from `imports`: that is the chunk graph, this is the island graph.
+     * Preloading has to be transitive over *this* - an island hydrating on load
+     * needs its children's chunks immediately, even though they are separate
+     * chunks.
+     */
+    uses: string[];
+    /** Mounts a component named by an expression, so it can reach anything. */
+    dynamic?: boolean;
+    /**
+     * Placeholder markup. Needed client-side because a deferred island must
+     * render its skeleton *without* fetching the component - otherwise deferral
+     * defeats itself. Only matters where there is no build-rendered HTML: dev,
+     * and imperative mounts.
+     */
+    skeleton?: string;
+}
+/** What a page needs to be re-rendered without running the bundler. */
+export interface PageEntry {
+    /**
+     * The page's markup *before* islands were rendered, with the build's asset
+     * tags already injected.
+     *
+     * Kept because `dist/page.html` is finished output - re-rendering that would
+     * render already-rendered content. The shell is the input the build itself
+     * used, so a rebuild is the same operation with fresher data.
+     */
+    shell: string;
+    /** Build-time cell keys this page read, so a rebuild can be targeted. */
+    content: string[];
+}
+export interface Manifest {
+    version: number;
+    runtime?: {
+        url: string;
+    };
+    components: Record<string, ComponentEntry>;
+    /** Keyed by output filename, e.g. `blog.html`. */
+    pages?: Record<string, PageEntry>;
+    /** Every URL the build emitted. */
+    routes?: RouteEntry[];
+    /** Per page, the `style-src` hashes a host must allow. */
+    styleHashes?: Record<string, string[]>;
+}
+export interface RouteEntry {
+    page: string;
+    pattern?: string;
+    path: string;
+    /** Route params this output was rendered with, for re-rendering just it. */
+    params?: Record<string, string>;
+    /** Build-time cells this specific output read. */
+    content?: string[];
+    /**
+     * The cell this route enumerated from.
+     *
+     * An **enumeration** dependency, not a content one. The index decides *which
+     * pages exist*; it does not decide what an existing page renders. Treating
+     * it as content meant renaming one entry re-rendered every page in the
+     * collection - measured at 1000 pages as costing the same as a full build.
+     */
+    from?: string;
+    /** Where a runtime-resolved route is served from, when not the path itself. */
+    file?: string;
+}
+/**
+ * Whether a template mounts a component named by an expression.
+ *
+ * The build cannot know what `<Dynamic $is="field.type" />` will resolve to,
+ * so a page containing one can reach *any* component. That is what makes it
+ * the exception to page-scoping below.
+ */
+export declare function hasDynamicMarker(template: string): boolean;
+/** Component ids referenced by a compiled template. */
+export declare function componentsUsedIn(template: string): string[];
+/** Every island marker in a template, with the trigger it declares. */
+export declare function markersIn(template: string): Array<{
+    c: string;
+    hydrate?: string;
+}>;
+/**
+ * Components a page needs *immediately*.
+ *
+ * Seeded from islands the page hydrates on load, then followed through their
+ * templates - a child with no trigger of its own is needed as soon as its
+ * parent is. Anything left over is only ever fetched on a trigger.
+ *
+ * The point of separating them: components that always load together should be
+ * bundled together, because splitting things that are always fetched as a set
+ * costs compression and buys nothing.
+ */
+export declare function eagerComponents(pageHtml: string, templates: Record<string, string>): string[];
+export declare function buildManifest(definitions: ComponentDefinition[]): Manifest;
+/**
+ * Everything a page can reach, following `uses` transitively.
+ *
+ * A page carries only this much of the manifest, so a landing page with one
+ * island does not ship a map of the whole project.
+ */
+export declare function componentsForPage(pageHtml: string, manifest: Manifest): string[];
+/** The subset of the manifest a page inlines for its runtime. */
+export declare function manifestForPage(pageHtml: string, manifest: Manifest): Manifest;
+/** Critical CSS for one page, in dependency order. */
+export declare function criticalCssForPage(pageHtml: string, manifest: Manifest): string;