@aloudata/aloudata-design 3.0.19 → 3.0.21

package/dist/theme/generator/acceptedColorValues.d.ts

@@ -0,0 +1,97 @@
+export declare const acceptedColorValueFamilies: readonly ["neutral", "brand", "blue", "green", "yellow", "orange", "red", "purple", "semantic", "theme-mapping"];
+export type AcceptedColorValueFamily = (typeof acceptedColorValueFamilies)[number];
+export declare const acceptedPaletteValueFamilies: readonly ["neutral", "brand", "blue", "green", "yellow", "orange", "red", "purple"];
+export type AcceptedPaletteValueFamily = (typeof acceptedPaletteValueFamilies)[number];
+export declare const acceptedColorValueRecordTypes: readonly ["palette-value", "semantic-role", "theme-mapping", "brand-seed"];
+export type AcceptedColorValueRecordType = (typeof acceptedColorValueRecordTypes)[number];
+export declare const acceptedColorValueLifecycles: readonly ["accepted", "candidate", "deprecated"];
+export type AcceptedColorValueLifecycle = (typeof acceptedColorValueLifecycles)[number];
+export declare const acceptedColorValueFormats: readonly ["hex", "oklch", "hsl"];
+export type AcceptedColorValueFormat = (typeof acceptedColorValueFormats)[number];
+export declare const acceptedColorValueThemes: readonly ["light", "dark"];
+export type AcceptedColorValueTheme = (typeof acceptedColorValueThemes)[number];
+export declare const acceptedColorValueProvenanceDecisionStatuses: readonly ["accepted", "candidate", "deferred"];
+export type AcceptedColorValueProvenanceDecisionStatus = (typeof acceptedColorValueProvenanceDecisionStatuses)[number];
+export declare const acceptedColorValueProvenanceDerivations: readonly ["accepted", "derived", "mapped"];
+export type AcceptedColorValueProvenanceDerivation = (typeof acceptedColorValueProvenanceDerivations)[number];
+export declare const acceptedSemanticDomains: readonly ["content", "background", "surface", "border", "interaction", "feedback", "state", "special-context"];
+export type AcceptedSemanticDomain = (typeof acceptedSemanticDomains)[number];
+export declare const acceptedThemeMappingResolutionModes: readonly ["accepted-theme-mapping"];
+export type AcceptedThemeMappingResolutionMode = (typeof acceptedThemeMappingResolutionModes)[number];
+export declare const acceptedBrandSeedOverridePolicies: readonly ["default-only", "governed-override"];
+export type AcceptedBrandSeedOverridePolicy = (typeof acceptedBrandSeedOverridePolicies)[number];
+export declare const acceptedCommonPaletteScaleStops: readonly ["50", "100", "200", "300", "400", "500", "600", "700", "800", "900", "950"];
+export type AcceptedCommonPaletteScaleStop = (typeof acceptedCommonPaletteScaleStops)[number];
+export interface ValueSourceProvenance {
+    document: string;
+    section: string;
+    decisionStatus: AcceptedColorValueProvenanceDecisionStatus;
+    derivation: AcceptedColorValueProvenanceDerivation;
+    phase: string;
+    notes?: string;
+}
+export interface AcceptedColorValueBaseRecord {
+    id: string;
+    type: AcceptedColorValueRecordType;
+    family: AcceptedColorValueFamily;
+    name: string;
+    lifecycle: AcceptedColorValueLifecycle;
+    provenance: ValueSourceProvenance;
+    metadata?: Readonly<Record<string, unknown>>;
+}
+export interface AcceptedPaletteValueRecord extends AcceptedColorValueBaseRecord {
+    type: 'palette-value';
+    family: AcceptedPaletteValueFamily;
+    value: string;
+    format: AcceptedColorValueFormat;
+    scale: string;
+    role?: string;
+}
+export interface AcceptedSemanticRoleRecord extends AcceptedColorValueBaseRecord {
+    type: 'semantic-role';
+    family: 'semantic';
+    role: string;
+    domain: AcceptedSemanticDomain;
+}
+export interface AcceptedThemeMappingRecord extends AcceptedColorValueBaseRecord {
+    type: 'theme-mapping';
+    family: 'theme-mapping';
+    theme: AcceptedColorValueTheme;
+    role: string;
+    sourceToken: string;
+    resolutionMode: AcceptedThemeMappingResolutionMode;
+}
+export interface AcceptedBrandSeedRecord extends AcceptedColorValueBaseRecord {
+    type: 'brand-seed';
+    family: 'brand';
+    value: string;
+    format: AcceptedColorValueFormat;
+    generatedScaleFamily: 'brand';
+    overridePolicy: AcceptedBrandSeedOverridePolicy;
+}
+export type AcceptedColorValueRecord = AcceptedPaletteValueRecord | AcceptedSemanticRoleRecord | AcceptedThemeMappingRecord | AcceptedBrandSeedRecord;
+export type AcceptedColorValueSourceValidationIssueCode = 'invalid-record' | 'duplicate-id' | 'duplicate-name-in-family' | 'missing-required-field' | 'invalid-family' | 'invalid-record-type' | 'invalid-lifecycle' | 'invalid-color-format' | 'invalid-theme' | 'invalid-semantic-domain' | 'invalid-provenance-decision-status' | 'invalid-provenance-derivation' | 'invalid-resolution-mode' | 'invalid-override-policy' | 'invalid-record-family' | 'forbidden-authority' | 'missing-theme-mapping-source' | 'missing-scale-stop';
+export interface AcceptedColorValueSourceValidationIssue {
+    code: AcceptedColorValueSourceValidationIssueCode;
+    message: string;
+    path: string;
+}
+export interface AcceptedColorValueSourceValidationSummary {
+    totalRecords: number;
+    paletteValueCount: number;
+    semanticRoleCount: number;
+    themeMappingCount: number;
+    brandSeedCount: number;
+    errorCount: number;
+    warningCount: number;
+}
+export interface AcceptedColorValueSourceValidationResult {
+    valid: boolean;
+    errors: AcceptedColorValueSourceValidationIssue[];
+    warnings: AcceptedColorValueSourceValidationIssue[];
+    summary: AcceptedColorValueSourceValidationSummary;
+}
+export interface AcceptedColorValueSourceValidationOptions {
+    requireCompletePaletteScale?: boolean;
+}
+export declare function validateAcceptedColorValueSource(records: readonly AcceptedColorValueRecord[], options?: AcceptedColorValueSourceValidationOptions): AcceptedColorValueSourceValidationResult;

package/dist/theme/generator/acceptedColorValues.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/generator/cssArtifactEmitter.d.ts

@@ -0,0 +1,62 @@
+import { ResolvedGeneratorRecord, ValueResolutionResult } from './valueResolver.js';
+export type CssArtifactKind = 'css-variables';
+export interface CssArtifactEmitterOptions {
+    selector?: string;
+    includeHeaderComment?: boolean;
+    includeDiagnostics?: boolean;
+}
+export interface CssArtifactRecord {
+    originalRecordId: string;
+    sourceName: string;
+    targetName: string;
+    family: ResolvedGeneratorRecord['family'];
+    lifecycle: ResolvedGeneratorRecord['lifecycle'];
+    resolvedValue: string;
+    format: 'hex';
+    sourceValueName: string | null;
+    sourceFamily: ResolvedGeneratorRecord['sourceFamily'];
+    resolutionMode: ResolvedGeneratorRecord['resolutionMode'];
+}
+export type CssArtifactEmitterIssueCode = 'invalid-resolution' | 'missing-resolved-plan' | 'unresolved-records' | 'resolution-errors' | 'invalid-selector' | 'missing-target-name' | 'missing-resolved-value' | 'unsupported-format' | 'duplicate-target-name' | 'resolution-warning';
+export interface CssArtifactEmitterIssue {
+    code: CssArtifactEmitterIssueCode;
+    severity: 'error' | 'warning';
+    message: string;
+    recordId?: string;
+    targetName?: string | null;
+}
+export interface CssArtifact {
+    artifactVersion: 'phase-3-css-artifact-v1';
+    artifactKind: CssArtifactKind;
+    createdBy: {
+        module: 'cssArtifactEmitter';
+        stage: 'phase-3-step-17';
+        internalOnly: true;
+    };
+    selector: string;
+    cssText: string;
+    records: readonly CssArtifactRecord[];
+    diagnostics?: unknown;
+    metadata: {
+        source: 'ValueResolutionResult';
+        runtimeInjected: false;
+    } & Readonly<Record<string, unknown>>;
+}
+export interface CssArtifactEmitterSummary {
+    recordCount: number;
+    emittedVariableCount: number;
+    errorCount: number;
+    warningCount: number;
+}
+export interface CssArtifactEmitterResult {
+    valid: boolean;
+    artifact: CssArtifact | null;
+    errors: readonly CssArtifactEmitterIssue[];
+    warnings: readonly CssArtifactEmitterIssue[];
+    summary: CssArtifactEmitterSummary;
+}
+export interface CreateCssVariablesArtifactInput {
+    resolution: ValueResolutionResult;
+    options?: CssArtifactEmitterOptions;
+}
+export declare function createCssVariablesArtifact({ resolution, options: rawOptions, }: CreateCssVariablesArtifactInput): CssArtifactEmitterResult;

package/dist/theme/generator/cssArtifactEmitter.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/generator/generator.d.ts

@@ -0,0 +1,41 @@
+import { GeneratorDeliveryPlan, GeneratorGenerationMode, GeneratorOutputFamily, GeneratorOutputSchemaValidationResult } from './generatorOutputSchema.js';
+import { GeneratorMappingContractEntry, GeneratorMappingIssue } from './generatorMappingStrategy.js';
+export interface GeneratorDryRunSource {
+    kind: 'explicit-entries';
+    entryCount: number;
+    sourceVersion: string | null;
+    sourceFingerprint: string | null;
+}
+export interface GeneratorDryRunOptions {
+    family?: GeneratorOutputFamily;
+    sourceVersion?: string;
+    generationMode?: GeneratorGenerationMode;
+    orderBase?: number;
+    mappingVersion?: string;
+    sourceFingerprint?: string | null;
+}
+export type GeneratorDryRunErrorCode = 'empty-entries' | 'unsupported-output-family' | 'mapping-failed' | 'plan-validation-failed' | 'schema-provenance-workaround';
+export interface GeneratorDryRunError {
+    code: GeneratorDryRunErrorCode;
+    message: string;
+    path: string;
+}
+export interface GeneratorDryRunDiagnostics {
+    errors: readonly GeneratorDryRunError[];
+    warnings: readonly GeneratorDryRunError[];
+}
+export interface GeneratorDryRunMappingDiagnostics {
+    valid: boolean;
+    errors: readonly GeneratorMappingIssue[];
+    warnings: readonly GeneratorMappingIssue[];
+    recordCount: number;
+}
+export interface GeneratorDryRunResult {
+    valid: boolean;
+    plan?: GeneratorDeliveryPlan;
+    validation: GeneratorOutputSchemaValidationResult;
+    mappingDiagnostics: GeneratorDryRunMappingDiagnostics;
+    diagnostics: GeneratorDryRunDiagnostics;
+    source: GeneratorDryRunSource;
+}
+export declare function runGeneratorDryRun(entries: readonly GeneratorMappingContractEntry[], options?: GeneratorDryRunOptions): GeneratorDryRunResult;

package/dist/theme/generator/generator.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/generator/generatorDiff.d.ts

@@ -0,0 +1,53 @@
+import { GeneratorDeliveryPlan, GeneratorOutputFamily, GeneratorOutputSchemaValidationResult } from './generatorOutputSchema.js';
+import { CssVariablesInventory, TokenCssBridgeReport } from '../contract/tokenCssBridge';
+export type GeneratorDiffSeverity = 'warning' | 'error';
+export type GeneratorDiffCategory = 'matched' | 'missingInCss' | 'extraInCss' | 'legacyOnly' | 'duplicateCssVariable' | 'unsupportedFamily' | 'unresolvedValue' | 'schemaValidationError' | 'provenanceWarning';
+export interface GeneratorDiffItem {
+    category: GeneratorDiffCategory;
+    severity: GeneratorDiffSeverity;
+    blocking: boolean;
+    message: string;
+    name: string;
+    recordId?: string;
+    path?: string;
+    metadata?: Readonly<Record<string, unknown>>;
+}
+export interface GeneratorDiffSummary {
+    matched: number;
+    missingInCss: number;
+    extraInCss: number;
+    legacyOnly: number;
+    duplicateCssVariable: number;
+    unsupportedFamily: number;
+    unresolvedValue: number;
+    schemaValidationError: number;
+    provenanceWarning: number;
+    blockingCount: number;
+    warningCount: number;
+}
+export interface GeneratorDiffReport {
+    valid: boolean;
+    blocking: boolean;
+    summary: GeneratorDiffSummary;
+    matched: readonly GeneratorDiffItem[];
+    missingInCss: readonly GeneratorDiffItem[];
+    extraInCss: readonly GeneratorDiffItem[];
+    legacyOnly: readonly GeneratorDiffItem[];
+    duplicateCssVariable: readonly GeneratorDiffItem[];
+    unsupportedFamily: readonly GeneratorDiffItem[];
+    unresolvedValue: readonly GeneratorDiffItem[];
+    schemaValidationError: readonly GeneratorDiffItem[];
+    provenanceWarning: readonly GeneratorDiffItem[];
+    warnings: readonly GeneratorDiffItem[];
+    errors: readonly GeneratorDiffItem[];
+    planValidation: GeneratorOutputSchemaValidationResult;
+}
+export interface GeneratorDiffOptions {
+    supportedFamilies?: readonly GeneratorOutputFamily[];
+}
+export interface CreateGeneratorDiffReportInput {
+    plan: GeneratorDeliveryPlan;
+    css: TokenCssBridgeReport | CssVariablesInventory;
+    options?: GeneratorDiffOptions;
+}
+export declare function createGeneratorDiffReport({ plan, css, options, }: CreateGeneratorDiffReportInput): GeneratorDiffReport;

package/dist/theme/generator/generatorDiff.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/generator/generatorEmitter.d.ts

@@ -0,0 +1,73 @@
+import { ResolvedGeneratorRecord, ValueResolutionIssue, ValueResolutionResult, ValueResolutionSummary } from './valueResolver.js';
+export type GeneratorManifestArtifactKind = 'resolved-generator-manifest';
+export interface GeneratorManifestArtifactRecord {
+    originalRecordId: string;
+    sourceName: string;
+    targetName: string | null;
+    family: ResolvedGeneratorRecord['family'];
+    lifecycle: ResolvedGeneratorRecord['lifecycle'];
+    resolvedValue: string | null;
+    format: ResolvedGeneratorRecord['format'];
+    sourceValueName: string | null;
+    sourceFamily: ResolvedGeneratorRecord['sourceFamily'];
+    resolutionMode: ResolvedGeneratorRecord['resolutionMode'];
+    provenance: ResolvedGeneratorRecord['provenance'];
+    warnings: readonly ValueResolutionIssue[];
+}
+export interface GeneratorManifestArtifact {
+    artifactVersion: 'phase-3-manifest-v1';
+    artifactKind: GeneratorManifestArtifactKind;
+    valid: boolean;
+    createdBy: {
+        module: 'generatorEmitter';
+        stage: 'phase-3-step-16';
+        internalOnly: true;
+    };
+    source: {
+        resolverVersion: string;
+        resolverStage: string;
+        valueSourceRecordCount: number;
+    };
+    originalPlanMetadata: Readonly<Record<string, unknown>> | null;
+    records: readonly GeneratorManifestArtifactRecord[];
+    diagnostics: {
+        errors: readonly ValueResolutionIssue[];
+        warnings: readonly ValueResolutionIssue[];
+        summary: ValueResolutionSummary;
+    };
+    recordCount: number;
+    metadata: {
+        emitterVersion: string;
+        emitterStage: 'phase-3-step-16';
+        artifactRecordCount: number;
+    };
+}
+export type GeneratorManifestEmitterIssueCode = 'invalid-resolution' | 'missing-resolved-plan' | 'unresolved-records' | 'resolution-errors';
+export interface GeneratorManifestEmitterIssue {
+    code: GeneratorManifestEmitterIssueCode;
+    severity: 'error' | 'warning';
+    message: string;
+}
+export interface GeneratorManifestEmitterSummary {
+    artifactCreated: boolean;
+    recordCount: number;
+    errorCount: number;
+    warningCount: number;
+}
+export interface GeneratorManifestEmitterResult {
+    valid: boolean;
+    artifact: GeneratorManifestArtifact | null;
+    errors: readonly GeneratorManifestEmitterIssue[];
+    warnings: readonly ValueResolutionIssue[];
+    summary: GeneratorManifestEmitterSummary;
+}
+export interface GeneratorManifestEmitterOptions {
+    includeOriginalPlanMetadata?: boolean;
+    includeProvenance?: boolean;
+    includeWarnings?: boolean;
+}
+export interface CreateGeneratorManifestArtifactInput {
+    resolution: ValueResolutionResult;
+    options?: GeneratorManifestEmitterOptions;
+}
+export declare function createGeneratorManifestArtifact({ resolution, options: rawOptions, }: CreateGeneratorManifestArtifactInput): GeneratorManifestEmitterResult;

package/dist/theme/generator/generatorEmitter.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/generator/generatorMappingStrategy.d.ts

@@ -0,0 +1,43 @@
+import { GeneratorOutputFamily, GeneratorOutputMetadata, GeneratorOutputRecord, GeneratorOutputSourceKind } from './generatorOutputSchema.js';
+export type GeneratorMappingContractDelivery = 'css-variable';
+export type GeneratorMappingContractLifecycle = 'active' | 'compatibility' | 'deprecated';
+export interface GeneratorMappingContractCompatibility {
+    source?: string;
+    reason: string;
+}
+export interface GeneratorMappingContractEntry {
+    name: string;
+    group: string;
+    delivery: GeneratorMappingContractDelivery;
+    lifecycle: GeneratorMappingContractLifecycle;
+    compatibility?: GeneratorMappingContractCompatibility;
+    description?: string;
+}
+export interface GeneratorMappingOptions {
+    family?: GeneratorOutputFamily;
+    entryIndex?: number;
+    orderBase?: number;
+    sourceKind?: GeneratorOutputSourceKind;
+    metadata?: GeneratorOutputMetadata;
+}
+export type GeneratorMappingIssueCode = 'invalid-contract-entry' | 'invalid-delivery' | 'invalid-lifecycle' | 'invalid-order' | 'schema-validation-error' | 'unsupported-output-family';
+export interface GeneratorMappingIssue {
+    code: GeneratorMappingIssueCode;
+    message: string;
+    path: string;
+}
+export interface GeneratorMappingResult {
+    valid: boolean;
+    record?: GeneratorOutputRecord;
+    errors: GeneratorMappingIssue[];
+    warnings: GeneratorMappingIssue[];
+}
+export interface GeneratorMappingRecordsResult {
+    valid: boolean;
+    records: GeneratorOutputRecord[];
+    errors: GeneratorMappingIssue[];
+    warnings: GeneratorMappingIssue[];
+}
+export declare function mapContractEntryToGeneratorOutputRecord(entry: GeneratorMappingContractEntry, options?: GeneratorMappingOptions): GeneratorMappingResult;
+export declare function mapContractEntriesToGeneratorOutputRecords(entries: readonly GeneratorMappingContractEntry[], options?: Omit<GeneratorMappingOptions, 'entryIndex'>): GeneratorMappingRecordsResult;
+export declare function sortGeneratorOutputRecords(records: readonly GeneratorOutputRecord[]): GeneratorOutputRecord[];

package/dist/theme/generator/generatorMappingStrategy.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/generator/generatorOutputSchema.d.ts

@@ -0,0 +1,80 @@
+export declare const generatorOutputFamilies: readonly ["css-variable", "design-token-json", "typescript-token-map", "tailwind-mapping", "figma-token", "native-token"];
+export type GeneratorOutputFamily = (typeof generatorOutputFamilies)[number];
+export declare const generatorOutputLifecycles: readonly ["canonical", "compatibility", "deprecated", "unmapped"];
+export type GeneratorOutputLifecycle = (typeof generatorOutputLifecycles)[number];
+export declare const generatorOutputSourceKinds: readonly ["token-output-contract", "compatibility-metadata", "migration-metadata", "manual-governance"];
+export type GeneratorOutputSourceKind = (typeof generatorOutputSourceKinds)[number];
+export declare const generatorOutputTargetKinds: readonly ["css-variable", "json-token", "typescript-export", "tailwind-theme-entry", "figma-token-entry", "native-token-entry"];
+export type GeneratorOutputTargetKind = (typeof generatorOutputTargetKinds)[number];
+export declare const generatorOutputValueSlotKinds: readonly ["unresolved-reference", "compatibility-reference", "manual-placeholder"];
+export type GeneratorOutputValueSlotKind = (typeof generatorOutputValueSlotKinds)[number];
+export declare const generatorGenerationModes: readonly ["schema-only-placeholder", "dry-run-placeholder", "emission-placeholder"];
+export type GeneratorGenerationMode = (typeof generatorGenerationModes)[number];
+export type GeneratorOutputGroup = string;
+export type GeneratorOutputMetadata = Readonly<Record<string, unknown>>;
+export interface GeneratorOutputValueSlot {
+    kind: GeneratorOutputValueSlotKind;
+    reference: string;
+    resolved: false;
+    fallbackReference?: string;
+    metadata?: GeneratorOutputMetadata;
+}
+export interface GeneratorOutputRecord {
+    id: string;
+    sourceName: string;
+    sourceKind: GeneratorOutputSourceKind;
+    targetName: string | null;
+    targetKind: GeneratorOutputTargetKind | null;
+    family: GeneratorOutputFamily;
+    lifecycle: GeneratorOutputLifecycle;
+    group: GeneratorOutputGroup;
+    order: number;
+    valueSlot: GeneratorOutputValueSlot;
+    metadata: GeneratorOutputMetadata;
+}
+export interface GeneratorDeliveryPlanSource {
+    canonicalAnchor: 'token-output-contract';
+    referenceKinds: readonly GeneratorOutputSourceKind[];
+    sourceFingerprint: string | null;
+    sourceVersion: string;
+}
+export interface GeneratorDeliveryPlanCreatedBy {
+    module: 'generator-output-schema';
+    stage: 'phase-3-step-2';
+    internalOnly: true;
+}
+export interface GeneratorDeliveryPlanDeterminism {
+    stableOrderingKey: 'order';
+    sourceFingerprint: string | null;
+    generationMode: GeneratorGenerationMode;
+    outputFamilies: readonly GeneratorOutputFamily[];
+    recordCount: number;
+}
+export interface GeneratorDeliveryPlan {
+    version: string;
+    source: GeneratorDeliveryPlanSource;
+    records: readonly GeneratorOutputRecord[];
+    families: readonly GeneratorOutputFamily[];
+    createdBy: GeneratorDeliveryPlanCreatedBy;
+    determinism: GeneratorDeliveryPlanDeterminism;
+    metadata: GeneratorOutputMetadata;
+}
+export type GeneratorOutputSchemaValidationIssueCode = 'invalid-plan' | 'invalid-record' | 'invalid-value-slot' | 'duplicate-record-id' | 'invalid-record-order' | 'unknown-family' | 'unknown-lifecycle' | 'unknown-source-kind' | 'unknown-target-kind' | 'missing-target' | 'unmapped-target-present' | 'invalid-determinism-record-count';
+export interface GeneratorOutputSchemaValidationIssue {
+    code: GeneratorOutputSchemaValidationIssueCode;
+    message: string;
+    path: string;
+}
+export interface GeneratorOutputSchemaValidationResult {
+    valid: boolean;
+    errors: GeneratorOutputSchemaValidationIssue[];
+    warnings: GeneratorOutputSchemaValidationIssue[];
+}
+export declare function isGeneratorOutputFamily(value: unknown): value is GeneratorOutputFamily;
+export declare function isGeneratorOutputLifecycle(value: unknown): value is GeneratorOutputLifecycle;
+export declare function isGeneratorOutputSourceKind(value: unknown): value is GeneratorOutputSourceKind;
+export declare function isGeneratorOutputTargetKind(value: unknown): value is GeneratorOutputTargetKind;
+export declare function isGeneratorOutputValueSlotKind(value: unknown): value is GeneratorOutputValueSlotKind;
+export declare function isGeneratorGenerationMode(value: unknown): value is GeneratorGenerationMode;
+export declare function validateGeneratorOutputRecord(record: unknown, path?: string): GeneratorOutputSchemaValidationResult;
+export declare function validateGeneratorDeliveryPlan(plan: unknown): GeneratorOutputSchemaValidationResult;

package/dist/theme/generator/generatorOutputSchema.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/generator/minimalAcceptedColorValues.d.ts

@@ -0,0 +1,27 @@
+import { AcceptedPaletteValueRecord, ValueSourceProvenance } from './acceptedColorValues.js';
+export declare const minimalAcceptedPaletteValues: readonly [AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord];
+export declare const minimalAcceptedBrandSeedValues: readonly [{
+    readonly id: "brand-seed:default-brand";
+    readonly type: "brand-seed";
+    readonly family: "brand";
+    readonly name: "default-brand";
+    readonly lifecycle: "accepted";
+    readonly provenance: ValueSourceProvenance;
+    readonly value: "#3162D4";
+    readonly format: "hex";
+    readonly generatedScaleFamily: "brand";
+    readonly overridePolicy: "default-only";
+}];
+export declare const minimalAcceptedColorValues: readonly [AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, AcceptedPaletteValueRecord, {
+    readonly id: "brand-seed:default-brand";
+    readonly type: "brand-seed";
+    readonly family: "brand";
+    readonly name: "default-brand";
+    readonly lifecycle: "accepted";
+    readonly provenance: ValueSourceProvenance;
+    readonly value: "#3162D4";
+    readonly format: "hex";
+    readonly generatedScaleFamily: "brand";
+    readonly overridePolicy: "default-only";
+}];
+export declare function validateMinimalAcceptedColorValues(): import('./acceptedColorValues').AcceptedColorValueSourceValidationResult;

package/dist/theme/generator/minimalAcceptedColorValues.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/generator/valueResolver.d.ts

@@ -0,0 +1,64 @@
+import { GeneratorDeliveryPlan, GeneratorOutputFamily, GeneratorOutputLifecycle } from './generatorOutputSchema.js';
+import { AcceptedColorValueFormat, AcceptedColorValueRecord, AcceptedPaletteValueFamily, ValueSourceProvenance } from './acceptedColorValues.js';
+export type ValueResolutionIssueSeverity = 'error' | 'warning';
+export type ValueResolutionIssueCode = 'invalid-plan' | 'invalid-value-source' | 'unsupported-family' | 'missing-value-reference' | 'missing-accepted-value' | 'unsupported-semantic-reference' | 'fallback-disabled';
+export interface ValueResolutionIssue {
+    code: ValueResolutionIssueCode;
+    severity: ValueResolutionIssueSeverity;
+    message: string;
+    recordId?: string;
+    sourceName?: string;
+    targetName?: string | null;
+    reference?: string;
+}
+export type ValueResolutionMode = 'accepted-palette-reference' | 'unresolved' | 'unsupported';
+export interface ResolvedGeneratorRecord {
+    originalRecordId: string;
+    sourceName: string;
+    targetName: string | null;
+    family: GeneratorOutputFamily;
+    lifecycle: GeneratorOutputLifecycle;
+    resolvedValue: string | null;
+    format: AcceptedColorValueFormat | null;
+    sourceValueName: string | null;
+    sourceFamily: AcceptedPaletteValueFamily | null;
+    provenance: ValueSourceProvenance | null;
+    resolutionMode: ValueResolutionMode;
+    warnings: readonly ValueResolutionIssue[];
+}
+export interface ResolvedGeneratorDeliveryPlan {
+    originalPlan: GeneratorDeliveryPlan;
+    records: readonly ResolvedGeneratorRecord[];
+    metadata: {
+        resolverVersion: string;
+        resolverStage: 'phase-3-step-14';
+        valueSourceRecordCount: number;
+    };
+}
+export interface ValueResolutionSummary {
+    totalRecords: number;
+    resolvedRecords: number;
+    unresolvedRecords: number;
+    errorCount: number;
+    warningCount: number;
+    unsupportedFamilyRecords: number;
+    missingSourceValues: number;
+}
+export interface ValueResolutionResult {
+    valid: boolean;
+    resolved: readonly ResolvedGeneratorRecord[];
+    unresolved: readonly ResolvedGeneratorRecord[];
+    errors: readonly ValueResolutionIssue[];
+    warnings: readonly ValueResolutionIssue[];
+    summary: ValueResolutionSummary;
+    plan: ResolvedGeneratorDeliveryPlan | null;
+}
+export interface ValueResolverOptions {
+    allowColorVariablePrefixNormalization?: boolean;
+}
+export interface ResolveGeneratorValuesInput {
+    plan: GeneratorDeliveryPlan;
+    valueSource: readonly AcceptedColorValueRecord[];
+    options?: ValueResolverOptions;
+}
+export declare function resolveGeneratorValues({ plan, valueSource, options, }: ResolveGeneratorValuesInput): ValueResolutionResult;

package/dist/theme/generator/valueResolver.js

@@ -0,0 +1,2 @@
+// type-only module stub
+export {};

package/dist/theme/governance/migrationMappingRegistry.d.ts

@@ -0,0 +1,22 @@
+export type MigrationMappingType = 'alias' | 'interaction' | 'non-semantic';
+export type MigrationMappingLifecycle = 'proposed' | 'accepted' | 'published' | 'deprecated' | 'removed' | 'blocked';
+export type MigrationMappingStrategy = 'direct-token-output' | 'semantic-equivalent' | 'component-token-output' | 'compatibility-output' | 'governance-review-required';
+export type LegacyCssVariableName = `--alias-${string}` | `--interaction-${string}` | `--non-semantic-${string}`;
+export type TokenOutputVariableName = `--${string}`;
+export interface MigrationMappingEntry {
+    source: LegacyCssVariableName;
+    target: TokenOutputVariableName | null;
+    type: MigrationMappingType;
+    lifecycle: MigrationMappingLifecycle;
+    strategy: MigrationMappingStrategy;
+    note?: string;
+}
+export declare const migrationMappingRegistry: readonly MigrationMappingEntry[];
+export declare const migrationMappingTableByType: {
+    alias: MigrationMappingEntry[];
+    interaction: MigrationMappingEntry[];
+    'non-semantic': MigrationMappingEntry[];
+};
+export declare function getMigrationMapping(source: LegacyCssVariableName): MigrationMappingEntry | undefined;
+export declare function getPublishedMigrationMappings(): MigrationMappingEntry[];
+export declare function assertOneWayMigrationMapping(): void;