@lightspeed-js/core 0.1.0

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

@@ -0,0 +1,57 @@
+import type { ComponentRegistry } from "../components/index.js";
+export declare class StyleManager {
+    private ssg;
+    private componentRegistry;
+    private styleElement;
+    private sheet;
+    private adopted;
+    private pendingStylesUsed;
+    /**
+     * Components whose CSS is already in the document.
+     *
+     * Additive rather than rewrite-from-scratch. A page carries critical CSS for
+     * everything it can *reach*, including components whose chunk has not loaded
+     * - a deferred island's skeleton is on screen long before its code is.
+     * Rebuilding this element from the registry would drop exactly those rules
+     * the moment anything registered, leaving the skeleton unstyled.
+     */
+    private covered;
+    private deferredCovered;
+    /**
+     * At build, deferred CSS is emitted separately at the end of the body so it
+     * stays off the critical path. On the client it travels with the component.
+     */
+    constructor(componentRegistry: ComponentRegistry, ssg?: boolean);
+    private ensureElement;
+    updateStyles(): void;
+    /** Called the first time an element opts into `$shimmer`. */
+    ensurePendingStyles(): void;
+    /** Component ids whose critical CSS this element carries. */
+    coveredComponents(): string[];
+    removeStyles(): void;
+    addComponentStyle(componentId: string, style: string): void;
+    removeComponentStyle(componentId: string): void;
+    /**
+     * Where CSS added at runtime goes.
+     *
+     * A `<style>` element is inline content, so a strict `style-src` blocks it -
+     * and a hash cannot cover CSS that does not exist until a chunk loads. A
+     * constructable stylesheet is CSSOM rather than inline content and is not
+     * checked at all, so a page with deferred component CSS needs no
+     * `unsafe-inline`.
+     *
+     * The build keeps writing a real `<style>` element: its output has to be
+     * serialisable HTML, and that block is hashed.
+     */
+    private emit;
+    /**
+     * The document's own `CSSStyleSheet`, not the global one.
+     *
+     * They are the same in a browser and not under jsdom, where the constructor
+     * hangs off the window rather than `globalThis` - so reading the global
+     * would silently take the fallback and leave the adopted path untested.
+     */
+    private sheetConstructor;
+    /** Whether this document can adopt a stylesheet. */
+    private adopts;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * When a component becomes live.
+ *
+ * `load` is the default and mounts inline. The others leave a skeleton in
+ * place and mount later, which is the point of the whole exercise: a page can
+ * paint its shape immediately and pay for interactivity only where it is
+ * needed.
+ */
+export type HydrationTrigger = "load" | "idle" | "visible" | "interaction"
+/**
+ * Never. The build renders it and the client leaves it alone.
+ *
+ * For markup that is finished once it is drawn - a published section, a
+ * footer. The build strips its markers entirely, so the browser does not
+ * mount it, does not fetch its chunk, and has nothing to adopt. The whole
+ * subtree goes static with it: a marker inside one has no parent instance
+ * left to evaluate its props against.
+ */
+ | "never"
+/**
+ * Always. The evidence says it could be static; the author says otherwise.
+ *
+ * The escape hatch for anything the build cannot see - a listener attached
+ * from a promise, a library reaching for the element after mount.
+ */
+ | "always";
+export declare function parseTrigger(value: string | null): HydrationTrigger;
+/**
+ * Arrange for `run` to happen when the trigger fires.
+ *
+ * Returns a cancel function. It must be registered on whatever owns the
+ * placeholder, so a component unmounted before its trigger fires does not
+ * leave an observer or a queued callback behind.
+ */
+export declare function scheduleHydration(trigger: HydrationTrigger, element: Element, run: () => void): () => void;

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

@@ -0,0 +1,7 @@
+export { Mounter } from "./Mounter.js";
+export type { InitInstance, ReleaseInstance } from "./Mounter.js";
+export { StyleManager } from "./StyleManager.js";
+export { ForBlock, Row } from "./ForBlock.js";
+export type { BindingHolder, RowRenderer } from "./ForBlock.js";
+export { parseTrigger, scheduleHydration } from "./hydration.js";
+export type { HydrationTrigger } from "./hydration.js";

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

@@ -0,0 +1,18 @@
+import type { ComponentInstance } from "../components/ComponentInstance.js";
+import type { BindingHolder } from "../dom/ForBlock.js";
+/**
+ * Attaches native event listeners at mount time.
+ *
+ * Handlers resolve against the instance that owns the element's scope, so a
+ * handler name means "this component's handler" rather than "whichever
+ * component happens to declare it first". Every listener registers its own
+ * removal on whatever owns it - the instance, or a single `$for` row - so
+ * unmounting that owner detaches it.
+ */
+export declare class EventBinder {
+    /** `@click="handleClick"` - a bare name. */
+    bind(el: Element, eventType: string, handlerName: string, owner: ComponentInstance, cleanupTarget?: BindingHolder): void;
+    /** `@click="remove(item)"` - an expression, needed for per-row actions. */
+    bindExpression(el: Element, eventType: string, invoke: (event: Event) => void, cleanupTarget: BindingHolder, label: string): void;
+    private listen;
+}

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

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

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

@@ -0,0 +1,24 @@
+import { ReactiveProxy } from "../reactive/index.js";
+import { SignalManager } from "../signals/index.js";
+export declare class GlobalFunctions {
+    private reactiveProxy;
+    private globalSignals;
+    constructor(reactiveProxy: ReactiveProxy, globalSignals: SignalManager);
+    setup(): void;
+    private defineProps;
+    private reactive;
+    private defineSignal;
+    /**
+     * The global escape hatch, for code that is not inside a component.
+     *
+     * A timer, and it has to be: there is no instance here and therefore no
+     * nodes to wait for. Components do **not** come through this - their
+     * `onMounted` is queued against the instance and released when its nodes are
+     * in the document, which is a promise this cannot make.
+     *
+     * Kept deliberately unimproved. Making it look reliable would invite the
+     * thing it cannot do.
+     */
+    private onMounted;
+    cleanup(): void;
+}

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

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

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

@@ -0,0 +1,141 @@
+/**
+ * Runtime helper functions for Lightspeed components
+ *
+ * These functions are available for import in component logic:
+ * ```typescript
+ * import { reactive, defineSignal, onMounted } from 'lightspeed'
+ * ```
+ *
+ * Note: These are type definitions for IDE support. At runtime, imports from 'lightspeed'
+ * are automatically transformed to use the injected runtime context.
+ */
+import type { SignalAPI } from './signals';
+/**
+ * Creates a reactive proxy object that triggers updates when properties change
+ *
+ * @example
+ * ```typescript
+ * import { reactive } from 'lightspeed'
+ *
+ * const state = reactive({ count: 0 })
+ * state.count = 1 // Triggers reactive update
+ * ```
+ */
+export declare function reactive<T extends object>(target: T): T;
+/**
+ * Creates a signal API for cross-component communication
+ *
+ * @example
+ * ```typescript
+ * import { defineSignal } from 'lightspeed'
+ *
+ * const signal = defineSignal()
+ * signal.emit('event:name', { data: 'value' })
+ * signal.on('event:name', (data) => console.log(data))
+ * ```
+ */
+export declare function defineSignal(): SignalAPI;
+/**
+ * Registers a callback to run when the component is mounted to the DOM
+ *
+ * @example
+ * ```typescript
+ * import { onMounted } from 'lightspeed'
+ *
+ * onMounted(() => {
+ *   console.log('Component mounted!')
+ * })
+ * ```
+ */
+export declare function onMounted(callback: () => void): void;
+/**
+ * Recompute derived state before this component's bindings read it.
+ *
+ * Runs on mount and again whenever this instance's state or props change -
+ * **props included**, which is the point: a component whose input can change
+ * under it derives from `props` here rather than snapshotting them at setup.
+ *
+ * Before the bindings rather than after, so a template never renders a value
+ * one pass behind.
+ *
+ * @example
+ * ```typescript
+ * import { defineProps, reactive, onUpdate } from 'lightspeed'
+ *
+ * const props = defineProps({ items: { default: [] } })
+ * const state = reactive({ summary: '' })
+ *
+ * onUpdate(() => {
+ *   state.summary = props.items.join(', ')
+ * })
+ * ```
+ */
+export declare function onUpdate(callback: () => void): void;
+/**
+ * The elements this component named with `$ref`, by name.
+ *
+ * @example
+ * ```typescript
+ * import { defineRefs, onMounted } from 'lightspeed'
+ *
+ * const refs = defineRefs()
+ *
+ * onMounted(() => {
+ *   // Filled by now: refs are collected when the DOM is, which is after the
+ *   // logic has run.
+ *   const width = refs.frame.getBoundingClientRect().width
+ * })
+ * ```
+ */
+export declare function defineRefs<T = Record<string, Element>>(): T;
+/**
+ * Defines component props with default values
+ *
+ * @example
+ * ```typescript
+ * import { defineProps } from 'lightspeed'
+ *
+ * const props = defineProps({
+ *   title: { default: 'Hello' },
+ *   count: { default: 0 }
+ * })
+ * ```
+ */
+export declare function defineProps<T = any>(propsDefinition?: any): T;
+/**
+ * Get or create a named shared cell.
+ *
+ * Cells are ownerless - whoever references a key first creates it. A cell that
+ * has never been set is `pending`, which is distinct from holding a falsy
+ * value, so a late-mounting component can tell "unknown" from "zero".
+ *
+ * @example
+ * ```typescript
+ * import { shared } from 'lightspeed'
+ *
+ * const clicks = shared('ui:clicks', 0)
+ * clicks.value++
+ *
+ * // One-shot async initialiser - runs once no matter how many callers pass it
+ * const revisions = shared('doc:revisions', async () => fetchRevisionCount())
+ *
+ * // Survives page loads
+ * const theme = shared('ui:theme', 'light', { persist: true })
+ * ```
+ */
+/**
+ * Put back whatever this component did to the world outside itself.
+ *
+ * A listener on `window`, an observer, a timer - anything the component owns
+ * that outlives its own DOM. Runs when the instance is destroyed.
+ */
+export declare function onUnmounted(callback: () => void): void;
+export declare function shared<T = any>(key: string, init?: T | (() => T | Promise<T>), options?: {
+    persist?: boolean;
+}): {
+    key: string;
+    value: T | undefined;
+    readonly pending: boolean;
+    set(next: T | undefined): void;
+    subscribe(listener: (value: T | undefined) => void): () => void;
+};

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

@@ -0,0 +1,16 @@
+export { createLightspeedApp, LightspeedRuntime } from "./core.js";
+export type { MountHandle } from "./core.js";
+export type { ComponentDefinition } from "./components/index.js";
+export { ComponentRegistry, ComponentInstance } from "./components/index.js";
+export { ReactiveProxy, UpdateScheduler } from "./reactive/index.js";
+export { SignalManager, createSignalAPI, createScopedSignalAPI, } from "./signals/index.js";
+export type { SignalAPI } from "./signals/index.js";
+export { ImportTransformer } from "./compiler/index.js";
+export { BindingEvaluator } from "./bindings/index.js";
+export type { Binding, BindingKind } from "./bindings/index.js";
+export { EventBinder } from "./events/index.js";
+export { Cell, CellManager } from "./state/index.js";
+export type { CellListener, CellOptions, CellInitialiser } from "./state/index.js";
+export { GlobalFunctions } from "./globals/index.js";
+export { Mounter, StyleManager } from "./dom/index.js";
+export { registerPageExpressions } from "./core.js";

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

@@ -0,0 +1,63 @@
+export declare class ReactiveProxy {
+    private onChange;
+    /**
+     * Per-owner cache of raw object -> proxy.
+     *
+     * Keyed by owner as well as target so two components sharing an object each
+     * get a proxy that notifies *them*. Caching also keeps proxy identity
+     * stable, which matters because bindings compare values with `Object.is` -
+     * a fresh proxy per read would look like a change on every evaluation.
+     */
+    private caches;
+    private ownerless;
+    /** proxy -> raw, so assigning a proxy back in does not nest wrappers. */
+    private rawTargets;
+    /**
+     * Every instance holding a proxy for a given object.
+     *
+     * A form shares one mutable object across components - the editor owns it,
+     * each field writes into it - so "notify the owner" is not enough: the
+     * owner's own bindings refresh and its siblings keep rendering the previous
+     * value. Notifying everyone who ever wrapped this object is what makes a
+     * shared object behave like shared state.
+     *
+     * Weak references, pruned as they die, so a component that has unmounted
+     * cannot be kept alive by an object its parent still holds.
+     */
+    private observers;
+    constructor(onChange: (owner: any) => void);
+    private cacheFor;
+    /**
+     * Wrap an object so writes notify the instance that owns it.
+     *
+     * Nested objects and arrays are wrapped lazily, on read, so `items.push(x)`
+     * and `items[0].name = 'x'` both notify. A `get` trap is affordable here
+     * because reads happen during binding evaluation, not in a render loop.
+     *
+     * `owner` lets the scheduler update only that instance's bindings. A null
+     * owner (the window-global `reactive()`) falls back to updating everything.
+     *
+     * `owner` must be an object or null - it keys a WeakMap so instances stay
+     * collectable.
+     */
+    create<T extends object>(target: T, owner?: any): T;
+    /**
+     * Register an instance as holding this object, wherever it came from.
+     *
+     * A prop is the case that needs it: a child is handed an object its parent
+     * wrapped, so it never calls `create` and would otherwise never hear that
+     * the object changed.
+     */
+    share(value: any, observer: object): void;
+    private observe;
+    /**
+     * Tell everyone holding this object that it changed.
+     *
+     * The writing owner is told first and always - a null owner is the
+     * window-global `reactive()`, whose fallback is to update everything, and
+     * that must not be lost just because nobody else happens to hold the object.
+     */
+    private notify;
+    /** The underlying object for a proxy, or the value itself if not one. */
+    raw<T>(value: T): T;
+}

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

@@ -0,0 +1,9 @@
+export declare class UpdateScheduler {
+    private queue;
+    private scheduled;
+    private flushCallback;
+    constructor(flushCallback: (owners: any[]) => void);
+    queueUpdate(owner: any): void;
+    private flushUpdates;
+    clear(): void;
+}

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

@@ -0,0 +1,2 @@
+export { ReactiveProxy } from "./ReactiveProxy.js";
+export { UpdateScheduler } from "./UpdateScheduler.js";

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

@@ -0,0 +1,10 @@
+export declare class SignalManager {
+    private listeners;
+    private history;
+    emit(event: string, data: any): void;
+    on(event: string, listener: Function): void;
+    off(event: string, listener: Function): void;
+    getHistory(event: string): any[];
+    getLatest(event: string): any | undefined;
+    clear(): void;
+}

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

@@ -0,0 +1,3 @@
+export { SignalManager } from "./SignalManager.js";
+export { createSignalAPI, createScopedSignalAPI } from "./signals.js";
+export type { SignalAPI } from "./types/index.js";

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

@@ -0,0 +1,16 @@
+import type { SignalManager } from "./SignalManager.js";
+import type { SignalAPI } from "./types/index.js";
+export declare function createSignalAPI(signalManager: any): SignalAPI;
+/**
+ * Create a signal API whose subscriptions are owned by a single caller.
+ *
+ * Every listener registered through `on` hands an unsubscribe back via
+ * `registerCleanup`, so the owner can drop all of its listeners at once when it
+ * is torn down. Without this, re-initialising a component (hot reload, or a
+ * manual `updateComponent`) leaves the previous instance's listeners attached to
+ * the shared manager and every signal fires once per stale instance.
+ *
+ * Takes a callback rather than a ComponentInstance so the signal layer stays
+ * independent of the component layer.
+ */
+export declare function createScopedSignalAPI(signalManager: SignalManager, registerCleanup: (cleanup: Function) => void): SignalAPI;

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

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

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

@@ -0,0 +1,7 @@
+export interface SignalAPI {
+    emit: (event: string, data: any) => void;
+    on: (event: string, listener: Function) => void;
+    off: (event: string, listener: Function) => void;
+    getHistory: (event: string) => any[];
+    getLatest: (event: string) => any | undefined;
+}

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

@@ -0,0 +1,68 @@
+export type CellListener<T = any> = (value: T | undefined) => void;
+export interface CellOptions {
+    /** Mirror the value into localStorage so it survives page loads. */
+    persist?: boolean;
+    /**
+     * When this cell's initialiser runs. See ADR-013.
+     *
+     * `"client"` (the default) is live state - current at the moment of viewing.
+     * `"build"` is *content*: managed elsewhere, published on a cadence, baked
+     * into the HTML and shipped to the client so it never fetches it again.
+     *
+     * Anything baked is public. Content worth caching is content worth serving
+     * publicly; anything user-specific or secret is live state by definition.
+     */
+    fetchAt?: "build" | "client";
+    /**
+     * Bake it, then go and get a fresh one.
+     *
+     * Only meaningful with `fetchAt: "build"`. The page paints with the value
+     * from the build and the initialiser runs again once, in the browser,
+     * replacing it when it lands.
+     *
+     * For data that changes **without a build** - a comment thread, a feed, a
+     * stock level. Published content is not that: it is rebuilt when it is
+     * published, so a baked entry is not stale, it is correct, and refreshing it
+     * would be a fetch for a value that cannot have changed.
+     *
+     * Showing a stale value at all is a decision only the author can make, which
+     * is why the default is the other one: declare no `fetchAt`, gate on
+     * `$needs`, and ship a skeleton until the real thing arrives.
+     */
+    refresh?: boolean;
+}
+/**
+ * A named unit of shared state.
+ *
+ * Distinct from a signal: a signal says "something happened", a cell holds
+ * "what is true now". A component that mounts late reads the current value
+ * instead of replaying a log of events.
+ *
+ * A cell that has never been set is `pending` - not zero, not defaulted.
+ * Pending is a real state, so a component can show its skeleton rather than
+ * asserting a value it does not have.
+ */
+export declare class Cell<T = any> {
+    readonly key: string;
+    private currentValue;
+    private isPending;
+    private listeners;
+    private persist;
+    constructor(key: string, options?: CellOptions);
+    get value(): T | undefined;
+    set value(next: T | undefined);
+    /** True until the first set. Distinguishes "unknown" from a falsy value. */
+    get pending(): boolean;
+    set(next: T | undefined): void;
+    /**
+     * Turn on persistence after the cell already exists.
+     *
+     * Needed because a cell is created by whoever touches the key first, and
+     * that is often an implicit *read* - a `$count="shared['x']"` binding on an
+     * island that hydrates before the component which declares the key properly.
+     * Without this, that declaration's options were silently discarded and the
+     * value never reached storage.
+     */
+    enablePersistence(): void;
+    subscribe(listener: CellListener<T>): () => void;
+}

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

@@ -0,0 +1,101 @@
+import { Cell, type CellOptions } from "./Cell.js";
+export type CellInitialiser<T = any> = () => T | Promise<T>;
+/**
+ * Owns every shared cell for a runtime.
+ *
+ * Cells are ownerless: whoever references a key first creates it, and everyone
+ * after gets the same cell. There is no registry to maintain and no central
+ * declaration file, which keeps state out of the way of the SFC model and
+ * works regardless of the order islands hydrate in.
+ */
+export declare class CellManager {
+    private ssg;
+    private cells;
+    private initialised;
+    private declaredDefaults;
+    /** Keys that refresh in the browser despite being baked. */
+    private refreshKeys;
+    /** Keys already refreshed this session, so several declarations fetch once. */
+    private refreshed;
+    /** Keys declared `fetchAt: "build"`, so only those are serialised. */
+    private buildKeys;
+    /** Outstanding build-time fetches, for the build to await. */
+    private buildWork;
+    /**
+     * At build, initialisers do not run.
+     *
+     * ADR-010 already says nothing is set at build - no fetches, localStorage
+     * stubbed - and an initialiser's value could not be used anyway, because the
+     * component gated on that cell ships its skeleton by definition. Running it
+     * only means hitting the network during a build and holding the process open
+     * until it settles: a 1-4s stand-in API took the example's build from 0.9s
+     * to 5.3s.
+     */
+    constructor(ssg?: boolean);
+    /**
+     * Get or create a cell.
+     *
+     * `init` is either a plain default value or a function used as a one-shot
+     * initialiser. An initialiser runs exactly once per key no matter how many
+     * callers pass one, which is what stops N components from firing N requests
+     * for the same data.
+     */
+    get<T = any>(key: string, init?: T | CellInitialiser<T>, options?: CellOptions): Cell<T>;
+    private applyDefault;
+    private runInitialiser;
+    /** Run an initialiser and put what it produces into the cell. */
+    private fetch;
+    /**
+     * Run `onReady` once every named cell holds a value. Returns a cancel.
+     *
+     * Fires **synchronously** when they are all resolved already, which is the
+     * common case for an island hydrating late: the data landed while it was
+     * waiting, so it renders with no skeleton at all.
+     *
+     * A cell never returns to pending once set, so this resolves at most once.
+     */
+    whenReady(keys: string[], onReady: () => void): () => void;
+    /** Which of these keys have never been set. */
+    pendingKeys(keys: string[]): string[];
+    /**
+     * Wait for every build-time fetch declared so far.
+     *
+     * Loops, because resolving one can mount a component whose logic declares
+     * another - a page's content cell filling in the section that fetches its
+     * own. Rejections propagate, which is what fails the build.
+     */
+    settleBuildData(): Promise<void>;
+    /** Whether this key's value came from the build rather than the browser. */
+    isBuildKey(key: string): boolean;
+    /**
+     * Baked and never fetched again.
+     *
+     * The distinction that matters to anything deciding whether a page needs
+     * JavaScript: a baked cell cannot change in the browser, but one that
+     * refreshes plainly can.
+     */
+    isBakedOnly(key: string): boolean;
+    /** Whether anything declared `fetchAt: "build"` during this render. */
+    hasBuildData(): boolean;
+    /** Resolved build-time content, for the page to carry to the client. */
+    buildPayload(): Record<string, unknown>;
+    /**
+     * Seed values the build resolved.
+     *
+     * Marked initialised as well as set, so the client does not re-fetch content
+     * it was handed - which would defeat the point and, worse, race with the
+     * rendered HTML.
+     */
+    seed(values: Record<string, unknown>): void;
+    has(key: string): boolean;
+    keys(): string[];
+    /**
+     * A view of every cell's current value, for evaluating template expressions.
+     *
+     * `onRead` reports which keys an expression actually touched, which is how a
+     * binding discovers what to subscribe to without any static analysis.
+     * Reading an unknown key creates it pending, consistent with get-or-create.
+     */
+    createReadProxy(onRead?: (key: string) => void): Record<string, any>;
+    clear(): void;
+}

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

@@ -0,0 +1,4 @@
+export { Cell } from "./Cell.js";
+export type { CellListener, CellOptions } from "./Cell.js";
+export { CellManager } from "./CellManager.js";
+export type { CellInitialiser } from "./CellManager.js";

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

@@ -0,0 +1,16 @@
+/**
+ * The names Lightspeed is imported by.
+ *
+ * The framework is published as `@lightspeed-js/core`: the unscoped name
+ * `lightspeed` on npm belongs to an unrelated package. Code written before the
+ * rename imports `'lightspeed'`, so that stays accepted everywhere the
+ * framework recognises its own imports, and the Vite plugin maps it to the
+ * package for everything else.
+ */
+export declare const PACKAGE_NAME = "@lightspeed-js/core";
+/** The name used before publishing. Still accepted; new code uses PACKAGE_NAME. */
+export declare const LEGACY_NAME = "lightspeed";
+/** Both names, for bundler `external` lists. */
+export declare const RUNTIME_SPECIFIERS: string[];
+/** Matches either name inside quotes, for import regexes. */
+export declare const SPECIFIER_PATTERN = "(?:@lightspeed-js\\/core|lightspeed)";

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

@@ -0,0 +1,21 @@
+/**
+ * The build-side surface.
+ *
+ * Separate from the runtime entry because these run in a build agent, not in a
+ * browser - a CMS webhook re-rendering pages has no use for the runtime, and a
+ * page has no use for jsdom.
+ */
+export { renderPage } from "./render.js";
+export type { RenderPageOptions, RenderPageResult } from "./render.js";
+export { rebuildPages } from "./rebuild.js";
+export type { RebuildOptions, RebuildResult } from "./rebuild.js";
+/**
+ * Route matching, for a server that has to honour a runtime-resolved route.
+ *
+ * A page whose URLs are not knowable at build ships one shell and relies on
+ * the host to rewrite onto it. A host that serves the output itself - rather
+ * than a static host reading `_redirects` - needs the same matcher the build
+ * and dev server use, or the three drift apart.
+ */
+export { parseRoute, matchPath, outputFileFor } from "../parser/route.js";
+export type { ParsedRoute } from "../parser/route.js";