@master/css-runtime 0.0.0-site.1793659883.g69c9aebcf628

package/dist/keyframe-host.d.ts

@@ -0,0 +1,25 @@
+import { MasterCSSKeyframeDefinition } from "@master/css-schema/manifest";
+/**
+ * Places the keyframes the engine emits in the runtime stylesheet, after its layers
+ * and wrapped in the containers each definition was declared in.
+ */
+declare class KeyframeHost {
+  private readonly sheet;
+  /** The engine's definitions, deduplicated by ID, in program order. */
+  private readonly definitions;
+  private readonly containers;
+  private readonly order;
+  constructor(sheet: () => CSSStyleSheet | undefined,
+  /** The engine's definitions, deduplicated by ID, in program order. */
+  definitions: () => readonly MasterCSSKeyframeDefinition[]);
+  reset(): void;
+  private definition;
+  private insertionIndex;
+  private parent;
+  insert(id: string, text: string): CSSRule | undefined;
+  contains(native: CSSRule | undefined): boolean;
+  remove(native: CSSRule | undefined): void;
+  /** Claims the pre-rendered rule of `id`, with its containers, from the runtime stylesheet. */
+  adopt(id: string, claimed: Set<CSSRule>): CSSKeyframesRule | undefined;
+}
+export { KeyframeHost as default };

package/dist/layer.d.ts

@@ -0,0 +1,35 @@
+import HydratedGeneratedRule from "./generated-rule";
+interface RuntimeResourceRule {
+  readonly key: string;
+  readonly name: string;
+  readonly text: string;
+  native?: CSSRule;
+  nativeNodeCount?: number;
+}
+type RuntimeLayerRule = HydratedGeneratedRule | RuntimeResourceRule;
+declare function getRuleNodeCount(rule: RuntimeLayerRule): number;
+type MutateNativeRule = (layer: RuntimeLayer, rule: RuntimeLayerRule, nativeIndex: number) => void;
+declare class RuntimeLayer {
+  readonly name: string;
+  private readonly insertRule;
+  private readonly deleteRule;
+  readonly rules: RuntimeLayerRule[];
+  readonly tokenCounts: Map<string, number>;
+  private readonly byKey;
+  private offsets;
+  private nodeCount;
+  native: CSSLayerBlockRule | null;
+  constructor(name: string, insertRule: MutateNativeRule, deleteRule: MutateNativeRule);
+  get text(): string;
+  get(key: string): RuntimeLayerRule | undefined;
+  /** Single-node layers and tail operations need no prefix traversal. */
+  nativeIndex(index: number): number;
+  private track;
+  /** Track an already hydrated rule without mutating the stylesheet. */
+  adopt(rule: RuntimeLayerRule): void;
+  insert(rule: RuntimeLayerRule, index?: number): number | undefined;
+  delete(key: string, index?: number): RuntimeResourceRule | undefined;
+  clearRules(): void;
+  reset(): void;
+}
+export { RuntimeLayerRule, RuntimeResourceRule, RuntimeLayer as default, getRuleNodeCount };

package/dist/mutation.d.ts

@@ -0,0 +1,14 @@
+import { MasterCSSRuntimeSnapshot } from "./types";
+interface RuntimeMutationContext {
+  classCounts: Map<string, number>;
+  isWarm(className: string): boolean;
+  ensure(classNames: string[]): unknown;
+  queueAdded(classNames: string[]): void;
+  queueRemoved(classNames: string[]): void;
+  cancelAdded(classNames: string[]): void;
+  debug(): [Document | ShadowRoot, Element, MasterCSSRuntimeSnapshot];
+}
+/** Counts class changes while the engine is deferred; returns newly connected classes. */
+declare function applyDeferredMutationDelta(deltaCounts: Map<string, number>, classCounts: Map<string, number>): string[];
+declare function applyRuntimeMutationDelta(records: MutationRecord[], deltaCounts: Map<string, number>, context: RuntimeMutationContext): void;
+export { applyDeferredMutationDelta, applyRuntimeMutationDelta };

package/dist/register-global.d.ts

@@ -0,0 +1,7 @@
+import { MasterCSSRuntime, MasterCSSRuntimeFacade } from "./core";
+declare global {
+  var MasterCSSRuntime: typeof MasterCSSRuntime;
+  var masterCSSRuntime: MasterCSSRuntimeFacade | undefined;
+}
+declare function registerGlobal(Runtime: typeof MasterCSSRuntime): void;
+export { registerGlobal as default };

package/dist/retention-config.d.ts

@@ -0,0 +1,20 @@
+declare const RETAINED_CLASS_RULE_MIN_AGE_MS = 1000;
+declare const RETAINED_CLASS_RULE_IDLE_TIMEOUT_MS = 5000;
+declare const RETAINED_CLASS_RULE_CLEANUP_BATCH_SIZE = 64;
+declare const RETAINED_CLASS_RULE_SOFT_TARGET = 128;
+declare const RETAINED_CLASS_RULE_HARD_LIMIT = 512;
+declare const RETAINED_CLASS_RULE_HARD_RAW_BYTES: number;
+interface RetainedClassRule {
+  retainedAt: number;
+  rawBytes: number;
+  ruleCount: number;
+}
+interface RuntimeCleanupWindow {
+  requestIdleCallback?: (callback: () => void, options?: {
+    timeout?: number;
+  }) => number;
+  cancelIdleCallback?: (handle: number) => void;
+  setTimeout: typeof globalThis.setTimeout;
+  clearTimeout: typeof globalThis.clearTimeout;
+}
+export { RETAINED_CLASS_RULE_CLEANUP_BATCH_SIZE, RETAINED_CLASS_RULE_HARD_LIMIT, RETAINED_CLASS_RULE_HARD_RAW_BYTES, RETAINED_CLASS_RULE_IDLE_TIMEOUT_MS, RETAINED_CLASS_RULE_MIN_AGE_MS, RETAINED_CLASS_RULE_SOFT_TARGET, RetainedClassRule, RuntimeCleanupWindow };

package/dist/startup.d.ts

@@ -0,0 +1,9 @@
+import { MasterCSSDiagnostic } from "@master/css-schema";
+declare const MASTER_CSS_RUNTIME_STARTUP_TIMEOUT_MS = 3000;
+/** Races startup steps against one deadline; `subject` names what failed to start. */
+declare function createStartupTimeout(view: Pick<typeof globalThis, 'setTimeout' | 'clearTimeout'>, timeoutMs: number, subject: 'runtime' | 'engine'): {
+  race: <T>(step: Promise<T>) => Promise<Awaited<T>>;
+  clear: () => void;
+};
+declare function toStartupDiagnostic(error: unknown): MasterCSSDiagnostic;
+export { MASTER_CSS_RUNTIME_STARTUP_TIMEOUT_MS, createStartupTimeout, toStartupDiagnostic };

package/dist/theme-layer.d.ts

@@ -0,0 +1,7 @@
+import RuntimeLayer from "./layer";
+declare class RuntimeThemeLayer extends RuntimeLayer {
+  resourceText: string;
+  get text(): string;
+  reset(): void;
+}
+export { RuntimeThemeLayer as default };

package/dist/types/hydrate-result.d.ts

@@ -0,0 +1,5 @@
+import HydratedGeneratedRule from "../generated-rule";
+interface HydrateResult {
+  allUtilities: HydratedGeneratedRule[];
+}
+export { HydrateResult };

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+import { MasterCSSEngine, MasterCSSEngineTransition } from "@master/css";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+import { MasterCSSHydrationManifest } from "@master/css-schema/hydration-manifest";
+import { LAYER_ORDER } from "./host";
+import { MasterCSSManifestUtilityLayerName } from "@master/css-schema/manifest";
+import { MasterCSSDiagnostic } from "@master/css-schema";
+/** A runtime program that `compileRuntimeProgram()` from `@master/css/node` compiled. */
+type MasterCSSRuntimeProgram = Uint8Array | ArrayBuffer;
+/** Loads the runtime program when the runtime starts its engine. */
+type MasterCSSRuntimeProgramLoader = () => Promise<MasterCSSRuntimeProgram>;
+/**
+ * `deferred` keeps a progressive page on its pre-rendered CSS until a class
+ * lacks it; `loading` and `failed` describe that start, `ready` executes rules.
+ */
+type MasterCSSRuntimeEngineState = 'deferred' | 'loading' | 'ready' | 'failed';
+interface MasterCSSRuntimeOptions {
+  readonly program: MasterCSSRuntimeProgram | MasterCSSRuntimeProgramLoader;
+  readonly root?: Document | ShadowRoot;
+  readonly emittedGlobals?: MasterCSSEmittedGlobals;
+  readonly hydrationManifest?: MasterCSSHydrationManifest;
+}
+type MasterCSSRuntimeBinding = 'auto' | 'native' | 'wasm';
+interface MasterCSSRuntimeStartOptions extends MasterCSSRuntimeOptions {
+  readonly binding?: MasterCSSRuntimeBinding;
+  /**
+   * Progressive pages with a hydration manifest defer the engine and a lazy
+   * program until a class lacks pre-rendered CSS. `eager` starts it now.
+   */
+  readonly engine?: 'eager' | 'deferred';
+  /** `idle` starts a deferred engine when the browser is idle, before a class needs it. */
+  readonly enginePrefetch?: 'none' | 'idle';
+  readonly startupTimeoutMs?: number;
+  readonly onDiagnostic?: (diagnostic: MasterCSSDiagnostic) => void;
+}
+interface MasterCSSRuntimeRuleSnapshot {
+  readonly key: string;
+  readonly layer: MasterCSSManifestUtilityLayerName;
+  readonly text: string;
+}
+interface MasterCSSRuntimeClassSnapshot {
+  readonly usageCount: number;
+  readonly retained: boolean;
+  readonly rules: readonly MasterCSSRuntimeRuleSnapshot[];
+}
+interface MasterCSSRuntimeLayerSnapshot {
+  readonly name: typeof LAYER_ORDER[number];
+  readonly cssText: string;
+  readonly ruleCount: number;
+}
+interface MasterCSSRuntimeSnapshot {
+  readonly binding: MasterCSSEngine['binding'] | undefined;
+  readonly engine: MasterCSSRuntimeEngineState;
+  readonly cssText: string;
+  readonly observing: boolean;
+  readonly classRules: Readonly<Record<string, MasterCSSRuntimeClassSnapshot>>;
+  readonly usageCounts: Readonly<Record<string, number>>;
+  readonly layers: readonly MasterCSSRuntimeLayerSnapshot[];
+  readonly hydration: {
+    readonly state: 'none' | 'runtime' | 'progressive';
+    readonly manifestLoaded: boolean;
+    readonly failureReason?: string;
+  };
+}
+interface MasterCSSRuntimeFacade extends Disposable {
+  readonly binding: MasterCSSEngine['binding'] | undefined;
+  ready(): Promise<this>;
+  observe(): this;
+  disconnect(): this;
+  refresh(program?: MasterCSSRuntimeProgram, emittedGlobals?: MasterCSSEmittedGlobals): this;
+  ensureClassRules(classNames: readonly string[]): MasterCSSEngineTransition;
+  deleteClassRules(classNames: readonly string[]): MasterCSSEngineTransition;
+  snapshot(): MasterCSSRuntimeSnapshot;
+  dispose(): void;
+}
+export { MasterCSSRuntimeBinding, MasterCSSRuntimeClassSnapshot, MasterCSSRuntimeEngineState, MasterCSSRuntimeFacade, MasterCSSRuntimeLayerSnapshot, MasterCSSRuntimeOptions, MasterCSSRuntimeProgram, MasterCSSRuntimeProgramLoader, MasterCSSRuntimeRuleSnapshot, MasterCSSRuntimeSnapshot, MasterCSSRuntimeStartOptions };

package/dist/utility-layer.d.ts

@@ -0,0 +1,8 @@
+import RuntimeLayer from "./layer";
+/**
+ * CSSOM host state for one generated utility layer. Class matching, ordering,
+ * resources, and lifecycle are owned by the Rust engine session.
+ */
+declare class RuntimeUtilityLayer extends RuntimeLayer {}
+declare type RuntimeUtilityLayerInstance = RuntimeUtilityLayer;
+export { RuntimeUtilityLayerInstance, RuntimeUtilityLayer as default };

package/dist/utils/find-native-css-rule-index.d.ts

@@ -0,0 +1,2 @@
+declare function findNativeCSSRuleIndex(cssRules: CSSRuleList, nativeRule: CSSRule): number;
+export { findNativeCSSRuleIndex as default };

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@master/css-runtime",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "license": "MIT",
+    "description": "Browser runtime for Master CSS",
+    "author": "Aoyue Design LLC.",
+    "homepage": "https://css.master.co",
+    "bugs": {
+        "url": "https://github.com/master-co/css/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/master-co/css.git",
+        "directory": "packages/runtime"
+    },
+    "keywords": [
+        "utility",
+        "css",
+        "lightweight",
+        "mastercss",
+        "master",
+        "runtime",
+        "cdn"
+    ],
+    "sideEffects": false,
+    "browser": "./dist/global.min.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./default-program": {
+            "types": "./dist/default-program.d.ts",
+            "default": "./dist/default-program.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "dependencies": {
+        "@master/css": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-binding": "0.0.0-site.1793659883.g69c9aebcf628",
+        "@master/css-schema": "0.0.0-site.1793659883.g69c9aebcf628"
+    },
+    "version": "0.0.0-site.1793659883.g69c9aebcf628",
+    "gitHead": "69c9aebcf628eb529001b9fa1b3536306f1b139e"
+}