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

package/README.md

@@ -0,0 +1,5 @@
+# @master/css-schema
+
+Public Master CSS schema and wire-format contracts.
+
+This package owns dependency-light types, serializable constants, and pure codec helpers shared by the compiler, engine, runtime, integrations, and tooling.

package/dist/css-common.d.ts

@@ -0,0 +1,2 @@
+type Vendors = 'webkit' | 'moz' | 'ms' | 'o';
+export { Vendors };

package/dist/css-common.js

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

package/dist/css-directives.d.ts

@@ -0,0 +1,145 @@
+import { MasterCSSKeyframeDefinition } from "./keyframes.js";
+import { MasterCSSMixinDefinition, MasterCSSMixinNode, MasterCSSMixinValue, MasterCSSUtilityDefinition } from "./mixin.js";
+import { MasterCSSThemeNode } from "./manifest.js";
+type CSSDirectiveVariableValue = number | string | false | (number | string)[];
+type CSSDirectiveDeclarations = Record<string, string>;
+interface CSSDirectiveSourceRange {
+  start: number;
+  end: number;
+}
+interface CSSDirectiveSourceLocation {
+  line: number;
+  column: number;
+}
+interface CSSDirectiveSourceReference {
+  file?: string;
+  range: CSSDirectiveSourceRange;
+  loc?: {
+    start: CSSDirectiveSourceLocation;
+    end: CSSDirectiveSourceLocation;
+  };
+}
+interface CSSDirectiveRelatedInformation {
+  message: string;
+  source?: CSSDirectiveSourceReference;
+}
+declare class CSSDirectiveError extends Error {
+  code: string;
+  source?: CSSDirectiveSourceReference;
+  related?: CSSDirectiveRelatedInformation[];
+  constructor(code: string, message: string, source?: CSSDirectiveSourceReference, related?: CSSDirectiveRelatedInformation[]);
+}
+declare function createCSSDirectiveSourceReference(file: string | undefined, range: CSSDirectiveSourceRange, source?: string): CSSDirectiveSourceReference;
+interface CSSCustomMediaDefinition {
+  name: string;
+  query: string;
+  source?: CSSDirectiveSourceReference;
+}
+/** An `@custom-container` condition as written, before references expand. */
+interface CSSCustomContainerDefinition {
+  name: string;
+  query: string;
+  source?: CSSDirectiveSourceReference;
+}
+interface CSSDirectiveManifestInput {
+  keyframes?: MasterCSSKeyframeDefinition[];
+  keyframeSafelist?: string[];
+  animationVariables?: Record<string, string[]>;
+  theme?: MasterCSSThemeNode[];
+  customMedia?: CSSCustomMediaDefinition[];
+  customContainers?: CSSCustomContainerDefinition[];
+  mixins?: MasterCSSMixinDefinition[];
+  utilities?: MasterCSSUtilityDefinition[];
+}
+interface CSSDirectiveExtractionPolicy {
+  include: string[];
+  exclude: string[];
+  safelist: string[];
+  safelistKeyframes: string[];
+  blocklist: (string | RegExp)[];
+  preserveNative: boolean;
+  pruneNative: boolean;
+}
+interface CSSDirectiveReference {
+  source: string;
+  file?: string;
+}
+interface CSSOrderedDeclaration {
+  property: string;
+  value: string;
+  source?: CSSDirectiveSourceReference;
+}
+interface CSSDirectiveStyleNativeDefinition {
+  type: 'native';
+  order: number;
+  selector: string;
+  declarations: CSSOrderedDeclaration[];
+  source?: CSSDirectiveSourceReference;
+  selectorSource?: CSSDirectiveSourceReference;
+  /** The enclosing conditional and layer preludes, outermost first. */
+  conditions?: string[];
+}
+interface CSSDirectiveStyleApplyDefinition {
+  type: 'apply';
+  order: number;
+  selector: string;
+  name: string;
+  arguments: MasterCSSMixinValue[];
+  contents?: MasterCSSMixinNode[];
+  selectorSource?: CSSDirectiveSourceReference;
+  source?: CSSDirectiveSourceReference;
+  /** The enclosing conditional and layer preludes, outermost first. */
+  conditions?: string[];
+}
+type CSSDirectiveStyleDefinition = CSSDirectiveStyleApplyDefinition | CSSDirectiveStyleNativeDefinition;
+/** Generated UTF-16 offset and its original authoring-source anchor. */
+interface CSSOutputMapping {
+  generatedStart: number;
+  generatedEnd?: number;
+  source: CSSDirectiveSourceReference;
+}
+/** Rust output plan; pass it unchanged from parsing to directive lowering. */
+interface CSSNativeOutput {
+  css: string;
+  mappings: CSSOutputMapping[];
+  slots: {
+    start: number;
+    end: number;
+    marker: string;
+    definitions: CSSDirectiveStyleDefinition[];
+  }[];
+}
+interface CSSDefinitionSource {
+  kind: 'utility' | 'mixin';
+  name: string;
+  identity: string;
+  replacedBy?: CSSDirectiveSourceReference;
+  source: CSSDirectiveSourceReference;
+}
+interface CSSDirectiveNotice {
+  code: string;
+  message: string;
+  source?: CSSDirectiveSourceReference | null;
+}
+interface CSSDirectiveResult {
+  notices?: CSSDirectiveNotice[];
+  definitionSources?: CSSDefinitionSource[];
+  nativeOutput?: CSSNativeOutput;
+  outputMappings?: CSSOutputMapping[];
+  /** Serialized source map v3 for the final CSS, when produced by the stylesheet host. */
+  sourceMap?: string;
+  nativeMappings?: CSSOutputMapping[];
+  generatedMappings?: CSSOutputMapping[];
+  manifestInput: CSSDirectiveManifestInput;
+  extractionPolicy: CSSDirectiveExtractionPolicy;
+  classNames: string[];
+  nativeClassNames: string[];
+  nativeCSS: string;
+  css: string;
+  generatedCSS: string;
+  warnings: string[];
+  dependencies: string[];
+  references?: CSSDirectiveReference[];
+  styleDefinitions?: CSSDirectiveStyleDefinition[];
+}
+export { CSSCustomContainerDefinition, CSSCustomMediaDefinition, CSSDefinitionSource, CSSDirectiveDeclarations, CSSDirectiveError, CSSDirectiveExtractionPolicy, CSSDirectiveManifestInput, CSSDirectiveNotice, CSSDirectiveReference, CSSDirectiveRelatedInformation, CSSDirectiveResult, CSSDirectiveSourceLocation, CSSDirectiveSourceRange, CSSDirectiveSourceReference, CSSDirectiveStyleApplyDefinition, CSSDirectiveStyleDefinition, CSSDirectiveStyleNativeDefinition, CSSDirectiveVariableValue, CSSNativeOutput, CSSOrderedDeclaration, CSSOutputMapping, createCSSDirectiveSourceReference };

package/dist/css-directives.js

@@ -0,0 +1,36 @@
+// src/css-directives.ts
+var CSSDirectiveError = class extends Error {
+	code;
+	source;
+	related;
+	constructor(code, message, source, related) {
+		super(message);
+		this.name = "CSSDirectiveError";
+		this.code = code;
+		this.source = source;
+		this.related = related;
+	}
+};
+function offsetToLocation(source, offset) {
+	let line = 1;
+	let column = 1;
+	for (let index = 0; index < offset && index < source.length; index++) if (source[index] === "\n") {
+		line++;
+		column = 1;
+	} else column++;
+	return {
+		line,
+		column
+	};
+}
+function createCSSDirectiveSourceReference(file, range, source) {
+	return {
+		...file ? { file } : {},
+		range,
+		...source ? { loc: {
+			start: offsetToLocation(source, range.start),
+			end: offsetToLocation(source, range.end)
+		} } : {}
+	};
+}
+export { CSSDirectiveError, createCSSDirectiveSourceReference };

package/dist/css-syntax.d.ts

@@ -0,0 +1,78 @@
+import { MasterCSSManifestUtilityLayerName, MasterCSSManifestVariableNumericValue } from "./manifest.js";
+type ValueComponent = StringValueComponent | NumberValueComponent | FunctionValueComponent | VariableValueComponent | SeparatorValueComponent;
+interface StringValueComponent {
+  text?: string;
+  token: string;
+  type: 'string';
+  value: string;
+}
+interface NumberValueComponent {
+  text?: string;
+  token: string;
+  type: 'number';
+  value: number;
+  unit?: string;
+}
+interface FunctionValueComponent {
+  text?: string;
+  token: string;
+  type: 'function';
+  name: string;
+  symbol: string;
+  children: ValueComponent[];
+  bypassTransform?: boolean;
+}
+interface VariableValueComponent {
+  text?: string;
+  token: string;
+  type: 'variable';
+  name: string;
+  alpha?: number;
+  fallback?: string;
+  negative?: boolean;
+  variable?: Variable;
+}
+interface SeparatorValueComponent {
+  text?: string;
+  token: string;
+  type: 'separator';
+  value: string;
+}
+type ExplicitUtilityLayerName = MasterCSSManifestUtilityLayerName;
+interface MediaFeatureComponent {
+  type: string;
+  tokenType?: string;
+  operator?: string;
+  value: number;
+  unit: string;
+}
+interface MediaQuery {
+  token: string;
+  features: Record<string, MediaFeatureComponent>;
+  type?: string;
+}
+interface VariableCommon {
+  namespace?: string;
+  name: string;
+  key: string;
+  inline?: boolean;
+  static?: boolean;
+  modes?: Record<string, ResolvedVariableValue>;
+  dependencies?: Set<string>;
+}
+interface StringVariable {
+  type: 'string';
+  value: string | number;
+}
+interface NumberVariable {
+  type: 'number';
+  value: number | string;
+  numeric?: MasterCSSManifestVariableNumericValue;
+}
+type ResolvedVariableValue = StringVariable | NumberVariable;
+type Variable = VariableCommon & {
+  type: ResolvedVariableValue['type'];
+  value?: ResolvedVariableValue['value'];
+  numeric?: MasterCSSManifestVariableNumericValue;
+};
+export { ExplicitUtilityLayerName, FunctionValueComponent, MediaFeatureComponent, MediaQuery, NumberValueComponent, NumberVariable, ResolvedVariableValue, SeparatorValueComponent, StringValueComponent, StringVariable, ValueComponent, Variable, VariableValueComponent };

package/dist/css-syntax.js

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

package/dist/diagnostics.d.ts

@@ -0,0 +1,41 @@
+declare const MASTER_CSS_DIAGNOSTIC_VERSION: 2;
+type MasterCSSDiagnosticDomain = 'binding' | 'compiler' | 'engine' | 'integration' | 'language' | 'project' | 'runtime' | 'server' | 'tooling';
+type MasterCSSDiagnosticSeverity = 'error' | 'warning' | 'information';
+interface MasterCSSDiagnosticPosition {
+  line: number;
+  character: number;
+}
+interface MasterCSSDiagnosticRange {
+  start: MasterCSSDiagnosticPosition;
+  end: MasterCSSDiagnosticPosition;
+}
+interface MasterCSSDiagnostic {
+  readonly version: typeof MASTER_CSS_DIAGNOSTIC_VERSION;
+  readonly code: string;
+  readonly domain: MasterCSSDiagnosticDomain;
+  readonly phase?: 'match' | 'css-syntax' | 'css-value' | 'browser-support' | 'compiler';
+  readonly severity: MasterCSSDiagnosticSeverity;
+  readonly message: string;
+  readonly source?: string;
+  readonly range?: MasterCSSDiagnosticRange;
+  readonly notes?: readonly string[];
+  readonly help?: string;
+}
+interface MasterCSSErrorPayload {
+  readonly code: string;
+  readonly domain: MasterCSSDiagnosticDomain;
+  readonly message: string;
+  readonly diagnostics?: readonly MasterCSSDiagnostic[];
+}
+interface MasterCSSErrorOptions extends ErrorOptions {
+  diagnostics?: readonly MasterCSSDiagnostic[];
+}
+declare class MasterCSSError extends Error {
+  readonly code: string;
+  readonly domain: MasterCSSDiagnosticDomain;
+  readonly diagnostics: readonly MasterCSSDiagnostic[];
+  readonly payload: MasterCSSErrorPayload;
+  constructor(payload: MasterCSSErrorPayload, options?: MasterCSSErrorOptions);
+  toJSON(): MasterCSSErrorPayload;
+}
+export { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSDiagnostic, MasterCSSDiagnosticDomain, MasterCSSDiagnosticPosition, MasterCSSDiagnosticRange, MasterCSSDiagnosticSeverity, MasterCSSError, MasterCSSErrorOptions, MasterCSSErrorPayload };

package/dist/diagnostics.js

@@ -0,0 +1,35 @@
+// src/diagnostics.ts
+const MASTER_CSS_DIAGNOSTIC_VERSION = 2;
+function freezeDiagnostic(diagnostic) {
+	return Object.freeze({
+		...diagnostic,
+		...diagnostic.range ? { range: Object.freeze({
+			start: Object.freeze({ ...diagnostic.range.start }),
+			end: Object.freeze({ ...diagnostic.range.end })
+		}) } : {},
+		...diagnostic.notes ? { notes: Object.freeze([...diagnostic.notes]) } : {}
+	});
+}
+var MasterCSSError = class extends Error {
+	code;
+	domain;
+	diagnostics;
+	payload;
+	constructor(payload, options = {}) {
+		super(payload.message, options);
+		this.name = "MasterCSSError";
+		this.code = payload.code;
+		this.domain = payload.domain;
+		this.diagnostics = Object.freeze((options.diagnostics ?? payload.diagnostics ?? []).map(freezeDiagnostic));
+		this.payload = Object.freeze({
+			code: this.code,
+			domain: this.domain,
+			message: this.message,
+			...this.diagnostics.length ? { diagnostics: this.diagnostics } : {}
+		});
+	}
+	toJSON() {
+		return this.payload;
+	}
+};
+export { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError };

package/dist/emitted-globals.d.ts

@@ -0,0 +1,7 @@
+/** Resource counts already emitted outside the current Rust engine session. */
+interface MasterCSSEmittedGlobals {
+  variables?: Record<string, number>;
+  /** Counts keyed by definition ID, rather than animation name. */
+  keyframes?: Record<string, number>;
+}
+export { MasterCSSEmittedGlobals };

package/dist/emitted-globals.js

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

package/dist/hydration-manifest.d.ts

@@ -0,0 +1,66 @@
+import { MasterCSSManifestUtilityLayerName } from "./manifest.js";
+import { MasterCSSEmittedGlobals } from "./emitted-globals.js";
+import { UtilityType } from "./utility-type.js";
+declare const MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID = "master-css-hydration-manifest";
+declare const MASTER_CSS_HYDRATION_MANIFEST_ATTR = "data-master-css-hydration-manifest";
+declare const MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE = "/_master-css/hydration/";
+declare const MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME = "master-css-hydration";
+interface MasterCSSConditionRange {
+  readonly domain: string;
+  readonly feature: string;
+  readonly unit: string;
+  readonly lower: {
+    readonly value: number;
+    readonly inclusive: boolean;
+  } | null;
+  readonly upper: {
+    readonly value: number;
+    readonly inclusive: boolean;
+  } | null;
+}
+interface MasterCSSRulePriority {
+  /** Token values sort before raw values within the same cascade tier. */
+  readonly valuePriority?: -1 | 0;
+  /** Parsed declaration identity, independent of public aliases. */
+  readonly sortKey?: string;
+  readonly features: readonly MasterCSSConditionRange[];
+  readonly conditions?: readonly string[];
+  readonly selector: number;
+}
+interface MasterCSSHydrationRuleNode {
+  readonly text: string;
+}
+interface MasterCSSHydrationRule {
+  readonly className: string;
+  readonly key: string;
+  readonly layer: MasterCSSManifestUtilityLayerName;
+  readonly type: UtilityType;
+  readonly sortTier: number;
+  readonly priority: MasterCSSRulePriority;
+  readonly text: string;
+  readonly nodes?: readonly MasterCSSHydrationRuleNode[];
+  readonly selectorText?: string;
+  readonly variableNames?: readonly string[];
+  readonly keyframeNames?: readonly string[];
+  readonly retainAllKeyframes?: boolean;
+}
+interface MasterCSSHydrationManifest {
+  readonly version: 5;
+  readonly languageVersion: 18;
+  /**
+   * Every rendered class: those with rules in rule order, then those without, such as
+   * authored component classes, then classes manifest selectors reference without rules
+   * of their own, such as mode classes. The runtime treats them as covered by the
+   * pre-rendered CSS and replays them to verify it when the engine starts.
+   */
+  readonly classNames: readonly string[];
+  readonly resourceOrder: {
+    readonly variables: readonly string[];
+    readonly keyframes: readonly string[];
+  };
+  /** Resource counts the server render treated as emitted by the page's stylesheets. */
+  readonly emittedGlobals?: MasterCSSEmittedGlobals;
+}
+declare function serializeMasterCSSHydrationManifest(hydrationManifest: MasterCSSHydrationManifest): string;
+declare function createMasterCSSHydrationManifestScript(hydrationManifest: MasterCSSHydrationManifest): string;
+export { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, MasterCSSConditionRange, MasterCSSHydrationManifest, MasterCSSHydrationRule, MasterCSSHydrationRuleNode, MasterCSSRulePriority, createMasterCSSHydrationManifestScript, serializeMasterCSSHydrationManifest };

package/dist/hydration-manifest.js

@@ -0,0 +1,12 @@
+// src/hydration-manifest.ts
+const MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID = "master-css-hydration-manifest";
+const MASTER_CSS_HYDRATION_MANIFEST_ATTR = "data-master-css-hydration-manifest";
+const MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE = "/_master-css/hydration/";
+const MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME = "master-css-hydration";
+function serializeMasterCSSHydrationManifest(hydrationManifest) {
+	return JSON.stringify(hydrationManifest).replace(/</g, "\\u003c");
+}
+function createMasterCSSHydrationManifestScript(hydrationManifest) {
+	return `<script type="application/json" id="${MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID}">${serializeMasterCSSHydrationManifest(hydrationManifest)}<\/script>`;
+}
+export { MASTER_CSS_HYDRATION_MANIFEST_ASSET_BASE, MASTER_CSS_HYDRATION_MANIFEST_ATTR, MASTER_CSS_HYDRATION_MANIFEST_FILE_BASENAME, MASTER_CSS_HYDRATION_MANIFEST_SCRIPT_ID, createMasterCSSHydrationManifestScript, serializeMasterCSSHydrationManifest };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { MasterCSSManifest, flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, normalizeMasterCSSManifest, serializeMasterCSSManifest } from "./manifest.js";
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSDiagnostic, MasterCSSDiagnosticDomain, MasterCSSDiagnosticPosition, MasterCSSDiagnosticRange, MasterCSSDiagnosticSeverity, MasterCSSError, MasterCSSErrorOptions, MasterCSSErrorPayload } from "./diagnostics.js";
+import { MASTER_CSS_RENDERING_MODES, MasterCSSIntegrationOptions, MasterCSSIntegrationRuntimeOptions, MasterCSSRenderingMode, isMasterCSSRenderingMode } from "./integration.js";
+export { MASTER_CSS_DIAGNOSTIC_VERSION, MASTER_CSS_RENDERING_MODES, type MasterCSSDiagnostic, type MasterCSSDiagnosticDomain, type MasterCSSDiagnosticPosition, type MasterCSSDiagnosticRange, type MasterCSSDiagnosticSeverity, MasterCSSError, type MasterCSSErrorOptions, type MasterCSSErrorPayload, type MasterCSSIntegrationOptions, type MasterCSSIntegrationRuntimeOptions, type MasterCSSManifest, type MasterCSSRenderingMode, flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, isMasterCSSRenderingMode, normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { normalizeMasterCSSManifest, serializeMasterCSSManifest } from "./manifest-json.js";
+import { MASTER_CSS_RENDERING_MODES, isMasterCSSRenderingMode } from "./integration.js";
+import { MASTER_CSS_DIAGNOSTIC_VERSION, MasterCSSError } from "./diagnostics.js";
+import { flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables } from "./manifest.js";
+export { MASTER_CSS_DIAGNOSTIC_VERSION, MASTER_CSS_RENDERING_MODES, MasterCSSError, flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, isMasterCSSRenderingMode, normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/integration.d.ts

@@ -0,0 +1,14 @@
+declare const MASTER_CSS_RENDERING_MODES: readonly ['runtime', 'static', 'pre-render', 'progressive'];
+type MasterCSSRenderingMode = typeof MASTER_CSS_RENDERING_MODES[number];
+interface MasterCSSIntegrationRuntimeOptions {
+  enabled?: boolean;
+  avoidFOUC?: boolean;
+}
+interface MasterCSSIntegrationOptions {
+  enabled?: boolean;
+  mode?: MasterCSSRenderingMode;
+  pruneNativeCSS?: boolean;
+  runtime?: boolean | MasterCSSIntegrationRuntimeOptions;
+}
+declare function isMasterCSSRenderingMode(value: unknown): value is MasterCSSRenderingMode;
+export { MASTER_CSS_RENDERING_MODES, MasterCSSIntegrationOptions, MasterCSSIntegrationRuntimeOptions, MasterCSSRenderingMode, isMasterCSSRenderingMode };

package/dist/integration.js

@@ -0,0 +1,11 @@
+// src/integration.ts
+const MASTER_CSS_RENDERING_MODES = [
+	"runtime",
+	"static",
+	"pre-render",
+	"progressive"
+];
+function isMasterCSSRenderingMode(value) {
+	return MASTER_CSS_RENDERING_MODES.includes(value);
+}
+export { MASTER_CSS_RENDERING_MODES, isMasterCSSRenderingMode };

package/dist/keyframes.d.ts

@@ -0,0 +1,24 @@
+import { CSSDirectiveSourceReference } from "./css-directives.js";
+/**
+ * A native `@keyframes` rule of Master-compiled CSS. A `native` definition is
+ * delivered in place by its stylesheet or the host, and engines never emit it.
+ * Every other definition comes from a `@prune native` stylesheet and is emitted on
+ * demand, like a token, by the engine whose output references it.
+ */
+interface MasterCSSKeyframeDefinition {
+  id: string;
+  name: string;
+  text: string;
+  /** The enclosing conditional and layer rules an emitted definition is wrapped in. */
+  containers?: MasterCSSKeyframeContainer[];
+  native?: boolean;
+  /** `@safelist keyframes` emits the definition without a reference. */
+  safelisted?: boolean;
+  dependencies?: string[];
+  source?: CSSDirectiveSourceReference;
+}
+interface MasterCSSKeyframeContainer {
+  id: string;
+  prelude: string;
+}
+export { MasterCSSKeyframeContainer, MasterCSSKeyframeDefinition };

package/dist/keyframes.js

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

package/dist/manifest-json.d.ts

@@ -0,0 +1,4 @@
+import { MasterCSSManifest } from "./manifest.js";
+declare function normalizeMasterCSSManifest(manifest: MasterCSSManifest): MasterCSSManifest;
+declare function serializeMasterCSSManifest(manifest: MasterCSSManifest): string;
+export { normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/manifest-json.js

@@ -0,0 +1,29 @@
+// src/manifest-json.ts
+function getVariableName(namespace, variable) {
+	return variable.name || (namespace ? `${namespace}${variable.key ? "-" + variable.key : ""}` : variable.key);
+}
+function normalizeVariablesForJSON(variables) {
+	if (!variables) return;
+	const normalized = {};
+	for (const [namespace, definitions] of Object.entries(variables)) {
+		const nextDefinitions = definitions.map((definition) => {
+			const normalizedDefinition = { ...definition };
+			if (normalizedDefinition.namespace === namespace || !namespace) delete normalizedDefinition.namespace;
+			if (normalizedDefinition.name === getVariableName(namespace, normalizedDefinition)) delete normalizedDefinition.name;
+			if (normalizedDefinition.type === "string") delete normalizedDefinition.type;
+			return normalizedDefinition;
+		});
+		if (nextDefinitions.length) normalized[namespace] = nextDefinitions;
+	}
+	return Object.keys(normalized).length ? normalized : void 0;
+}
+function normalizeMasterCSSManifest(manifest) {
+	return {
+		...manifest,
+		...manifest.variables ? { variables: normalizeVariablesForJSON(manifest.variables) } : {}
+	};
+}
+function serializeMasterCSSManifest(manifest) {
+	return JSON.stringify(normalizeMasterCSSManifest(manifest));
+}
+export { normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/manifest.d.ts

@@ -0,0 +1,80 @@
+import { MasterCSSKeyframeDefinition, MasterCSSKeyframeDefinition as MasterCSSKeyframeDefinition$1 } from "./keyframes.js";
+import { MasterCSSMixinDefinition, MasterCSSMixinDefinition as MasterCSSMixinDefinition$1, MasterCSSMixinNode, MasterCSSMixinParameter, MasterCSSMixinParameterSyntax, MasterCSSMixinValue, MasterCSSUtilityDefinition, MasterCSSUtilityDefinition as MasterCSSUtilityDefinition$1 } from "./mixin.js";
+import { PropertiesHyphen } from "csstype";
+import { normalizeMasterCSSManifest, serializeMasterCSSManifest } from "./manifest-json.js";
+type MasterCSSManifestConditionIdentifier = 'container' | 'starting-style' | 'supports' | 'media' | 'layer';
+type MasterCSSManifestUtilityLayerName = 'base' | 'defaults' | 'components' | 'utilities';
+type MasterCSSManifestCSSDeclarationPrimitive = string | number | null;
+type MasterCSSManifestCSSDeclarations = PropertiesHyphen | Record<string, MasterCSSManifestCSSDeclarationPrimitive | MasterCSSManifestCSSDeclarationPrimitive[]>;
+type MasterCSSManifestVariableValue = number | string | false | (number | string)[];
+type MasterCSSManifestVariableType = 'number' | 'string';
+interface MasterCSSManifestVariableNumericValue {
+  value: number;
+  unit?: string;
+}
+interface MasterCSSManifestVariable {
+  name?: string;
+  key: string;
+  namespace?: string;
+  type?: MasterCSSManifestVariableType;
+  values: MasterCSSScopedThemeValue[];
+  numeric?: MasterCSSManifestVariableNumericValue;
+  dependencies?: string[];
+}
+type MasterCSSManifestVariables = Record<string, MasterCSSManifestVariable[]>;
+type MasterCSSManifestVariableEntry = MasterCSSManifestVariable & {
+  name: string;
+  namespace?: string;
+  type: MasterCSSManifestVariableType;
+};
+interface MasterCSSScopedThemeValue {
+  path: string[];
+  value: string;
+  inline?: boolean;
+  static?: boolean;
+}
+type MasterCSSThemeNode = {
+  type: 'rule';
+  prelude: string;
+  children: MasterCSSThemeNode[];
+} | {
+  type: 'declaration';
+  name: string;
+  value: string;
+  inline?: boolean;
+  static?: boolean;
+};
+type MasterCSSMediaQueryExpression = {
+  type: 'true' | 'false';
+} | {
+  type: 'feature';
+  value: string;
+} | {
+  type: 'media-type';
+  name: string;
+} | {
+  type: 'not';
+  query: MasterCSSMediaQueryExpression;
+} | {
+  type: 'and' | 'or';
+  queries: MasterCSSMediaQueryExpression[];
+};
+interface MasterCSSManifest {
+  /** MasterCSSManifest IR schema/codec version; engines reject any other version. */
+  version: 6;
+  languageVersion: 18;
+  keyframes?: MasterCSSKeyframeDefinition$1[];
+  animationVariables?: Record<string, string[]>;
+  theme?: MasterCSSThemeNode[];
+  customMedia?: Record<string, MasterCSSMediaQueryExpression>;
+  /** The expanded condition of each custom container, without references. */
+  customContainers?: Record<string, string>;
+  variables?: MasterCSSManifestVariables;
+  mixins?: MasterCSSMixinDefinition$1[];
+  utilities?: MasterCSSUtilityDefinition$1[];
+  debug?: Record<string, unknown>;
+}
+declare function getMasterCSSManifestVariableName(namespace: string, variable: Pick<MasterCSSManifestVariable, 'key' | 'name'>): string;
+declare function flattenMasterCSSManifestVariables(variables: MasterCSSManifestVariables | undefined): MasterCSSManifestVariableEntry[];
+declare function groupMasterCSSManifestVariables(variables: readonly MasterCSSManifestVariable[] | undefined): MasterCSSManifestVariables | undefined;
+export { type MasterCSSKeyframeDefinition, MasterCSSManifest, MasterCSSManifestCSSDeclarationPrimitive, MasterCSSManifestCSSDeclarations, MasterCSSManifestConditionIdentifier, MasterCSSManifestUtilityLayerName, MasterCSSManifestVariable, MasterCSSManifestVariableEntry, MasterCSSManifestVariableNumericValue, MasterCSSManifestVariableType, MasterCSSManifestVariableValue, MasterCSSManifestVariables, MasterCSSMediaQueryExpression, type MasterCSSMixinDefinition, type MasterCSSMixinNode, type MasterCSSMixinParameter, type MasterCSSMixinParameterSyntax, type MasterCSSMixinValue, MasterCSSScopedThemeValue, MasterCSSThemeNode, type MasterCSSUtilityDefinition, flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/manifest.js

@@ -0,0 +1,30 @@
+import { normalizeMasterCSSManifest, serializeMasterCSSManifest } from "./manifest-json.js";
+// src/manifest.ts
+function getMasterCSSManifestVariableName(namespace, variable) {
+	return variable.name || (namespace ? `${namespace}${variable.key ? "-" + variable.key : ""}` : variable.key);
+}
+function flattenMasterCSSManifestVariables(variables) {
+	const flattened = [];
+	for (const [namespace, definitions] of Object.entries(variables || {})) for (const definition of definitions) {
+		const type = definition.type || "string";
+		flattened.push({
+			...definition,
+			name: getMasterCSSManifestVariableName(namespace, definition),
+			...namespace ? { namespace } : {},
+			type
+		});
+	}
+	return flattened;
+}
+function groupMasterCSSManifestVariables(variables) {
+	if (!variables?.length) return;
+	const grouped = {};
+	for (const variable of variables) {
+		const namespace = variable.namespace || "";
+		const group = grouped[namespace] ||= [];
+		const { namespace: _namespace, ...definition } = variable;
+		group.push(definition);
+	}
+	return Object.keys(grouped).length ? grouped : void 0;
+}
+export { flattenMasterCSSManifestVariables, getMasterCSSManifestVariableName, groupMasterCSSManifestVariables, normalizeMasterCSSManifest, serializeMasterCSSManifest };

package/dist/mixin.d.ts

@@ -0,0 +1,49 @@
+import { CSSDirectiveSourceReference } from "./css-directives.js";
+type MasterCSSMixinParameterSyntax = 'integer' | 'number' | 'string' | 'custom-ident';
+interface MasterCSSMixinParameter {
+  name: string;
+  syntax?: MasterCSSMixinParameterSyntax;
+  default?: string;
+  source?: CSSDirectiveSourceReference;
+}
+type MasterCSSMixinValue = ({
+  type: 'text';
+  value: string;
+} | {
+  type: 'function';
+  name: string;
+  value: MasterCSSMixinValue;
+})[];
+type MasterCSSMixinNode = {
+  type: 'declaration';
+  property: string;
+  value: MasterCSSMixinValue;
+  source?: CSSDirectiveSourceReference;
+} | {
+  type: 'rule';
+  selector: string;
+  body: MasterCSSMixinNode[];
+} | {
+  type: 'condition';
+  condition: string;
+  body: MasterCSSMixinNode[];
+} | {
+  type: 'apply';
+  name: string;
+  arguments: MasterCSSMixinValue[];
+  contents?: MasterCSSMixinNode[];
+  source?: CSSDirectiveSourceReference;
+} | {
+  type: 'contents';
+  fallback: MasterCSSMixinNode[];
+};
+interface MasterCSSMixinDefinition {
+  name: string;
+  parameters?: MasterCSSMixinParameter[];
+  body: MasterCSSMixinNode[];
+  source?: CSSDirectiveSourceReference;
+}
+interface MasterCSSUtilityDefinition extends MasterCSSMixinDefinition {
+  kind: 'static' | 'token' | 'function';
+}
+export { MasterCSSMixinDefinition, MasterCSSMixinNode, MasterCSSMixinParameter, MasterCSSMixinParameterSyntax, MasterCSSMixinValue, MasterCSSUtilityDefinition };

package/dist/mixin.js

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

package/dist/runtime-style.d.ts

@@ -0,0 +1,2 @@
+declare const MASTER_CSS_RUNTIME_STYLE_ID = "master-css";
+export { MASTER_CSS_RUNTIME_STYLE_ID };

package/dist/runtime-style.js

@@ -0,0 +1,3 @@
+// src/runtime-style.ts
+const MASTER_CSS_RUNTIME_STYLE_ID = "master-css";
+export { MASTER_CSS_RUNTIME_STYLE_ID };

package/dist/utility-type.d.ts

@@ -0,0 +1,14 @@
+declare const UtilityType: {
+  /**
+   * semantic utility classes
+   * @example sr-only, text-sm
+   */
+  readonly Semantic: -2;
+  /**
+   * normal
+   * @example p-md, font-size:1rem
+   */
+  readonly Normal: 0;
+};
+type UtilityType = typeof UtilityType[keyof typeof UtilityType];
+export { UtilityType };

package/dist/utility-type.js

@@ -0,0 +1,14 @@
+// src/utility-type.ts
+const UtilityType = {
+	/**
+	* semantic utility classes
+	* @example sr-only, text-sm
+	*/
+	Semantic: -2,
+	/**
+	* normal
+	* @example p-md, font-size:1rem
+	*/
+	Normal: 0
+};
+export { UtilityType };

package/package.json

@@ -0,0 +1,96 @@
+{
+    "name": "@master/css-schema",
+    "type": "module",
+    "engines": {
+        "node": "^24"
+    },
+    "license": "MIT",
+    "description": "Public Master CSS schema and wire-format contracts.",
+    "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/schema"
+    },
+    "keywords": [
+        "schema",
+        "manifest",
+        "css",
+        "mastercss"
+    ],
+    "sideEffects": false,
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "default": "./dist/index.js"
+        },
+        "./manifest": {
+            "types": "./dist/manifest.d.ts",
+            "import": "./dist/manifest.js",
+            "default": "./dist/manifest.js"
+        },
+        "./hydration-manifest": {
+            "types": "./dist/hydration-manifest.d.ts",
+            "import": "./dist/hydration-manifest.js",
+            "default": "./dist/hydration-manifest.js"
+        },
+        "./css-directives": {
+            "types": "./dist/css-directives.d.ts",
+            "import": "./dist/css-directives.js",
+            "default": "./dist/css-directives.js"
+        },
+        "./css-syntax": {
+            "types": "./dist/css-syntax.d.ts",
+            "import": "./dist/css-syntax.js",
+            "default": "./dist/css-syntax.js"
+        },
+        "./utility-type": {
+            "types": "./dist/utility-type.d.ts",
+            "import": "./dist/utility-type.js",
+            "default": "./dist/utility-type.js"
+        },
+        "./runtime-style": {
+            "types": "./dist/runtime-style.d.ts",
+            "import": "./dist/runtime-style.js",
+            "default": "./dist/runtime-style.js"
+        },
+        "./emitted-globals": {
+            "types": "./dist/emitted-globals.d.ts",
+            "import": "./dist/emitted-globals.js",
+            "default": "./dist/emitted-globals.js"
+        },
+        "./css-common": {
+            "types": "./dist/css-common.d.ts",
+            "import": "./dist/css-common.js",
+            "default": "./dist/css-common.js"
+        },
+        "./diagnostics": {
+            "types": "./dist/diagnostics.d.ts",
+            "import": "./dist/diagnostics.js",
+            "default": "./dist/diagnostics.js"
+        },
+        "./integration": {
+            "types": "./dist/integration.d.ts",
+            "import": "./dist/integration.js",
+            "default": "./dist/integration.js"
+        }
+    },
+    "files": [
+        "dist"
+    ],
+    "publishConfig": {
+        "access": "public",
+        "provenance": true
+    },
+    "dependencies": {
+        "csstype": "^3.2.3"
+    },
+    "version": "0.0.0-site.1793659883.g69c9aebcf628",
+    "gitHead": "69c9aebcf628eb529001b9fa1b3536306f1b139e"
+}