@contentful/experience-design-system-types 2.42.1-dev-build-f69db6bf.0 → 2.43.0-alpha.0

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

@@ -0,0 +1,393 @@
+import type { EXPLORE_SCOPES } from './constants.js';
+import type { FinitePrimitiveValue } from '../cdf/finite-values.js';
+import type { JsonValue } from '../property-contract/json-value.js';
+export type ExploreScope = (typeof EXPLORE_SCOPES)[number];
+export type DiffScope = 'component' | 'prop' | 'slot';
+export type SourceCompleteness = 'complete-within-declared-bound' | 'partial' | 'unavailable';
+export interface ExplorationIdentity {
+    sessionId: string;
+    runId: string;
+    envelopeId: string;
+    digest: string;
+}
+export interface KnownComponent {
+    name: string;
+    source: string;
+    componentId?: string;
+}
+export interface VerifyEvidence {
+    source: string;
+    line: string;
+    quote: string;
+}
+export interface SlotRestriction {
+    kind: 'declared' | 'enforced';
+    applicable: boolean;
+    evidence: VerifyEvidence[];
+    supported?: boolean;
+}
+export interface ExploreSlotEvidence {
+    sourceInput?: import('../source-input-association.js').SourceInputAssociation;
+    name: string;
+    isRealSlot: boolean;
+    allowedComponents?: string[];
+    evidence?: string[];
+    required?: boolean;
+    reasoning?: string;
+    restriction?: SlotRestriction;
+}
+export interface ExplorePropReport {
+    name: string;
+    /** Recursive union branches form one complete desired definition. */
+    definition?: import('../cdf/types.js').CDFPropertyDefinition;
+    category?: 'content' | 'design' | 'state' | 'unattached';
+    type?: string;
+    values?: FinitePrimitiveValue[];
+    /** Observed values are evidence and do not establish a finite constraint. */
+    observedValues?: JsonValue[];
+    tokenKind?: string;
+    tokenPaths?: string[];
+    required?: boolean;
+    default?: unknown;
+    description?: string;
+    reasoning?: string;
+    /** One source-bound draft; mapper readiness remains caller-owned. */
+    representationProposal?: import('../property-contract/representation-proposal.js').RepresentationProposalDraft;
+}
+export interface ExploreComponentReport extends KnownComponent {
+    included?: boolean;
+    inclusionReasoning?: string;
+    modelingNotes?: string[];
+    props?: ExplorePropReport[];
+    slots?: ExploreSlotEvidence[];
+}
+export interface ExploreCompanion {
+    agentRole: ExploreScope;
+    components: ExploreComponentReport[];
+    rawTokenReferences?: Array<{
+        tokenPath: string;
+        file: string;
+        line: number;
+        property: string;
+    }>;
+}
+export interface AgentCallAttempt {
+    attempt: number;
+    ok: boolean;
+    error?: string;
+    stage?: string;
+    operationId?: string;
+    component?: string;
+    source?: string;
+    workIds?: readonly string[];
+    scope?: ExploreScope;
+    identity?: ExplorationIdentity;
+    startedAt?: string;
+    durationMs?: number;
+}
+export interface ExploreAttempt extends AgentCallAttempt {
+    scope: ExploreScope;
+}
+export interface ExploreReportCoverage {
+    requested: KnownComponent[];
+    answered: KnownComponent[];
+    excluded: KnownComponent[];
+    complete: true;
+}
+export interface ExploreScopeResult {
+    coverage?: ExploreReportCoverage;
+    scope: ExploreScope;
+    report: string;
+    companion: ExploreCompanion;
+    attempts: ExploreAttempt[];
+}
+export type ExploreStageResult = {
+    ok: true;
+    scopes: ExploreScopeResult[];
+} | {
+    ok: false;
+    scope: ExploreScope;
+    attempts: ExploreAttempt[];
+    error: string;
+    scopes?: ExploreScopeResult[];
+};
+export interface ExploreSourceRef {
+    compilerContexts?: import('../shared-source.js').SharedSourceCompilerContext[];
+    component: string;
+    sourcePath: string;
+    content: string | null;
+    sourceEvidence?: {
+        captureId: string;
+        captureDigest: string;
+        textHash: string | null;
+        coverage: SourceCompleteness;
+        extractionByteBinding: 'verified-same' | 'changed' | 'unverified';
+        lineRanges: Array<{
+            startLine: number;
+            endLine: number;
+        }>;
+        compilerContextId?: string;
+    };
+    siblingFiles?: Array<{
+        path: string;
+        content: string;
+        sourceEvidence?: ExploreSourceRef['sourceEvidence'];
+    }>;
+}
+export interface BoundSourceFile {
+    fileId: string;
+    compilerContextId?: string;
+    path: string;
+    textHash: string | null;
+    ranges: Array<{
+        startLine: number;
+        endLine: number;
+        text: string;
+    }>;
+    coverage: SourceCompleteness;
+    roles?: string[];
+    componentRefs?: import('../shared-source.js').SharedSourceFile['componentRefs'];
+}
+export interface ExplorationSourceInput {
+    inventory?: unknown;
+    omittedInventory?: number;
+    /** Legacy snapshot metadata; ignored and removed from new prompt projections. */
+    projectionBounds?: {
+        maxBytes: number;
+        usedBytes: number;
+    };
+    components?: import('../shared-source.js').SharedSource['components'];
+    compilerContexts?: import('../shared-source.js').SharedSourceCompilerContext[];
+    omittedCompilerContexts?: number;
+    omittedComponents?: number;
+    omittedRanges?: number;
+    captureId: string;
+    captureDigest: string;
+    envelopeId: string;
+    envelopeDigest: string;
+    coverage: SourceCompleteness;
+    promptCoverage: SourceCompleteness;
+    extractionByteBinding: 'verified-same' | 'changed' | 'unverified';
+    files: BoundSourceFile[];
+    omittedFiles: number;
+    omittedDiagnostics?: number;
+    omittedObservations?: number;
+    diagnostics: unknown[];
+    observations: NonNullable<import('../shared-source.js').SharedSource['observations']>;
+}
+export interface ExplorationDisagreement {
+    id: string;
+    component: string;
+    source: string;
+    scope: DiffScope;
+    member?: string;
+    field: string;
+    path: string;
+    valuesByScope: Partial<Record<ExploreScope, unknown>>;
+    reasonsByScope: Partial<Record<ExploreScope, string>>;
+    existenceDispute?: boolean;
+}
+export interface ExplorationSingleVoter {
+    id: string;
+    component: string;
+    source: string;
+    scope: DiffScope;
+    member?: string;
+    field: string;
+    path: string;
+    provider: ExploreScope;
+    value: unknown;
+    reason?: string;
+}
+export interface ExplorationConsensusField {
+    path: string;
+    value: unknown;
+    coverage: number;
+    providers: ExploreScope[];
+}
+export interface ExplorationDiff {
+    consensus: ExplorationConsensusField[];
+    disagreements: ExplorationDisagreement[];
+    singleVoters: ExplorationSingleVoter[];
+    warnings: string[];
+    scopesRead: number;
+    componentsSeen: number;
+}
+export interface DerivedSelection {
+    componentKey: string;
+    componentId?: string;
+    name: string;
+    source: string;
+    decision?: 'accepted' | 'rejected';
+    reason: string;
+    votes: {
+        accepted: number;
+        rejected: number;
+    };
+    dissent: Array<{
+        scope: string;
+        included: boolean;
+        reason: string;
+    }>;
+    disputed: boolean;
+}
+export type AcceptedSlotState = 'false' | 'unresolved' | 'open' | 'finite';
+export interface DerivedSlot {
+    name: string;
+    allowedComponents: string[];
+    state?: AcceptedSlotState;
+    required?: boolean;
+    evidence?: VerifyEvidence[];
+}
+export interface DerivedComponentSlots extends KnownComponent {
+    slots: DerivedSlot[];
+}
+export interface SlotDecision extends KnownComponent {
+    sourceInput?: import('../source-input-association.js').SourceInputAssociation;
+    slot: string;
+    state: AcceptedSlotState;
+    allowedComponents: string[];
+    required?: boolean;
+    evidence: VerifyEvidence[];
+    coverage: number;
+    realVotes: number;
+    description?: string;
+    provenance?: 'source-consensus' | 'human';
+    disputes?: SlotDispute[];
+}
+export interface SlotDispute {
+    component: string;
+    source: string;
+    slot: string;
+    field: 'isRealSlot' | 'allowedComponents';
+    disputeId: string;
+    valuesByScope: Record<string, unknown>;
+    reasonsByScope: Record<string, string | undefined>;
+}
+export interface DerivedSlots {
+    components: DerivedComponentSlots[];
+    disputes: SlotDispute[];
+    decisions: SlotDecision[];
+}
+export type HypothesisTier = 'factual' | 'interpretive';
+export interface TierHypothesis {
+    disagreementIds: string[];
+    hypothesis: string;
+    tier: HypothesisTier;
+    tierReason: string;
+    gatedOn?: 'category';
+}
+export type TierStageResult = {
+    ok: true;
+    hypotheses: TierHypothesis[];
+    attempts: AgentCallAttempt[];
+} | {
+    ok: false;
+    error: string;
+    attempts: AgentCallAttempt[];
+};
+export type VerifyOutcome = 'confirmed' | 'resolved' | 'conflicting';
+export type VerifyItemKind = 'factual' | 'single-voter';
+export interface VerifyClaim {
+    id: string;
+    path: string;
+    scope: DiffScope;
+    member?: string;
+    field: string;
+    valuesByScope: Partial<Record<ExploreScope, unknown>>;
+}
+export interface VerifyItem {
+    itemId: string;
+    kind: VerifyItemKind;
+    hypothesis?: string;
+    gatedOn?: 'category';
+    claims: VerifyClaim[];
+}
+export interface VerifyCallSite {
+    sourcePath: string;
+    startLine: number;
+    endLine: number;
+    child: string;
+    excerpt: string;
+}
+export interface VerifyComponentWork {
+    component: string;
+    source: string;
+    sourceRef?: ExploreSourceRef;
+    callSites: VerifyCallSite[];
+    evidenceLimits?: string[];
+    items: VerifyItem[];
+}
+export interface VerifyResolution {
+    path: string;
+    value: unknown;
+}
+export interface VerifiedItem {
+    itemId: string;
+    component: string;
+    source: string;
+    outcome: VerifyOutcome;
+    resolved?: VerifyResolution[];
+    evidence: VerifyEvidence[];
+    reason: string;
+    downgraded?: boolean;
+}
+export interface VerifyAttempt extends AgentCallAttempt {
+    component: string;
+}
+export type VerifyStageResult = {
+    ok: true;
+    items: VerifiedItem[];
+    attempts: VerifyAttempt[];
+} | {
+    ok: false;
+    component: string;
+    error: string;
+    attempts: VerifyAttempt[];
+};
+export type CheckVerdict = 'supports' | 'does-not-support' | 'unclear';
+export interface EvidenceCheck {
+    checkId: string;
+    itemId: string;
+    component: string;
+    source: string;
+    verdict: CheckVerdict;
+    reason: string;
+}
+export type CheckStageResult = {
+    ok: true;
+    items: VerifiedItem[];
+    checks: EvidenceCheck[];
+    attempts: VerifyAttempt[];
+} | {
+    ok: false;
+    component: string;
+    error: string;
+    attempts: VerifyAttempt[];
+};
+export type RendererReferenceInput = {
+    kind: 'url';
+    url?: string;
+} | {
+    kind: 'path';
+    path: string;
+} | {
+    kind: 'text';
+    text: string;
+    origin: string;
+};
+export interface RendererReference {
+    origin: string;
+    digest: string;
+    retrievedAt: string;
+    bytes: number;
+    coverage: 'complete-within-declared-bound';
+    text: string;
+}
+export interface ExplorationDetailRecord {
+    diff: ExplorationDiff;
+    hypotheses: TierHypothesis[];
+    verified: VerifiedItem[];
+    checks: EvidenceCheck[];
+    recordOnly: true;
+}

package/dist/src/exploration/types.js

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

package/dist/src/handoff/index.d.ts

@@ -24,9 +24,9 @@ declare const ImportHandoffSchema: z.ZodMiniObject<{
         existingEntitiesPath: z.ZodMiniNullable<z.ZodMiniString<string>>;
         /** Never 'running': the wizard starts its background cache check only once this has settled. */
         existingEntitiesStatus: z.ZodMiniEnum<{
+            complete: "complete";
             failed: "failed";
             idle: "idle";
-            complete: "complete";
         }>;
         /** The only phases the scope gate can start from. */
         compositionPhase: z.ZodMiniEnum<{

package/dist/src/index.d.ts

@@ -1,5 +1,19 @@
-export { validateCDF, parseCDFComponents, CDF_SCHEMA_URL, cdfJsonSchema, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, type CDFComponentEntry, type CDFPropertyDefinition, type CDFSlotDefinition, type CDFTokenEntry, type CDFValidationError, type CDFValidationResult, type CDFDocument, } from './cdf/index.js';
+export { shouldUseStdinForPrompt } from './agent-prompt-transport.js';
+export { createAgentPromptArtifact, shouldUsePromptArtifact, type AgentPromptArtifact, } from './agent-prompt-artifact.js';
+export { createAgentCancellationResult, runAgentProcess, type AgentProcessEndDetails, type AgentProcessResult, type RunAgentProcessOptions, } from './agent-process-lifecycle.js';
+export { validateCDF, parseCDFComponents, CDF_SCHEMA_URL, cdfJsonSchema, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, finiteValuesIssue, isFinitePrimitiveType, isFinitePrimitiveValue, type FinitePrimitiveType, type FinitePrimitiveValue, type CDFComponentEntry, type CDFPropertyDefinition, type CDFFieldDefinition, type CDFSlotDefinition, type CDFTokenEntry, type CDFValidationError, type CDFValidationResult, type CDFDocument, } from './cdf/index.js';
 export { DESIGN_TOKEN_TYPES, flattenDTCG, validateDTCG, DTCGTokenSchema, type DesignTokenType, type DTCGTokenEntry, type DTCGTokenGroup, type DTCGTokenNode, type DTCGTokenGroupNode, type DTCGValidationError, type DTCGValidationResult, } from './dtcg/index.js';
 export type { BreakingChange, ChangeClassification, DownstreamImpact, PropertySummary, ComponentTypeSummary, DesignTokenSummary, TaxonomySummary, ChangedEntity, EntityDiffGroup, ServerPreviewResponse, } from './sources-api/preview/index.js';
 export type { ApplyOperationStatus, ApplyOperationItemError, ApplyOperationItem, ApplyOperationResponse, ApplyGateError, } from './sources-api/apply/index.js';
+export * from './exploration/index.js';
+export type { SharedSource, SharedSourceFile, SharedSourceCompilerContext, SharedSourceReference, SharedSourceRange, SharedSourceCoverage, SharedSourceCallerCoverage, } from './shared-source.js';
 export * from './property-contract/index.js';
+export { validateCDFProperty, cdfToTarget, targetToCDF, cdfDefinitionChildren, containsCDFDefinitionType, } from './cdf/property-validation.js';
+export * from './source-input-association.js';
+export { PROPERTY_BREAKING_REASONS, SLOT_BREAKING_REASONS, sanitizeBreakingChanges, } from './sources-api/preview/index.js';
+export type { SlotSummary, ProjectionDiagnostic } from './sources-api/preview/index.js';
+export * from './schema-export.js';
+export { previewContractSchemas } from './sources-api/preview/schema.js';
+export { expandCDFModelDependencies } from './cdf/build.js';
+export { toOpenAPISchema } from './schema-export.js';
+export type { ProposedComponentSummary } from './sources-api/preview/index.js';

package/dist/src/index.js

@@ -1,9 +1,17 @@
 // CDF (Component Definition Format) exports — one schema/file for both
 // components and design tokens, no separate manifest envelope.
-export { validateCDF, parseCDFComponents, CDF_SCHEMA_URL, cdfJsonSchema, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, } from './cdf/index.js';
+export { shouldUseStdinForPrompt } from './agent-prompt-transport.js';
+export { createAgentPromptArtifact, shouldUsePromptArtifact, } from './agent-prompt-artifact.js';
+export { createAgentCancellationResult, runAgentProcess, } from './agent-process-lifecycle.js';
+export { validateCDF, parseCDFComponents, CDF_SCHEMA_URL, cdfJsonSchema, CDF_PROPERTY_TYPES, CDF_PROPERTY_CATEGORIES, CDFComponentSchema, CDFPropertySchema, CDFSlotSchema, CDFTokenSchema, buildCDF, buildFilteredCDF, stripUnsupportedSlotFields, validateSlotReferences, finiteValuesIssue, isFinitePrimitiveType, isFinitePrimitiveValue, } from './cdf/index.js';
 // DTCG (W3C Design Token Community Group)
 export { DESIGN_TOKEN_TYPES, flattenDTCG, validateDTCG, DTCGTokenSchema, } from './dtcg/index.js';
-// Property contract — pillar #4 foundation (target types + validators).
-// Dormant: no current consumer imports these. Available for forthcoming
-// evidence-aware extractors and generation. See INTEG-5147 / INTEG-4927.
+export * from './exploration/index.js';
 export * from './property-contract/index.js';
+export { validateCDFProperty, cdfToTarget, targetToCDF, cdfDefinitionChildren, containsCDFDefinitionType, } from './cdf/property-validation.js';
+export * from './source-input-association.js';
+export { PROPERTY_BREAKING_REASONS, SLOT_BREAKING_REASONS, sanitizeBreakingChanges, } from './sources-api/preview/index.js';
+export * from './schema-export.js';
+export { previewContractSchemas } from './sources-api/preview/schema.js';
+export { expandCDFModelDependencies } from './cdf/build.js';
+export { toOpenAPISchema } from './schema-export.js';

package/dist/src/property-contract/analysis-representation-candidates.d.ts

@@ -0,0 +1,19 @@
+import { type JsonValue } from './json-value.js';
+import { type LogicalSourceGraph } from './logical-source-graph.js';
+import { type PropertyModel } from './property-model.js';
+export interface AnalysisRepresentationCandidates {
+    identity: PropertyModel['identity'];
+    profileDigest: string;
+    candidateSetHash: string;
+    status: 'prepared' | 'invalid';
+    selectedCandidateId: null;
+    logicalGraph?: LogicalSourceGraph;
+    candidates: Array<{
+        id: string;
+        strategy: 'native' | 'component-model';
+        requires: 'category-and-representation-decision';
+    }>;
+    diagnostics: string[];
+}
+/** Strategies are source-derived alternatives, without a selected category or target readiness. */
+export declare function prepareAnalysisRepresentationCandidates(model: Pick<PropertyModel, 'identity' | 'source'>, profile?: JsonValue): AnalysisRepresentationCandidates;

package/dist/src/property-contract/analysis-representation-candidates.js

@@ -0,0 +1,45 @@
+import { contentDigest } from './content-digest.js';
+import { cloneJson, freezeJson } from './json-value.js';
+import { prepareLogicalSourceGraph } from './logical-source-graph.js';
+import { nativeSourceRegion } from './native-source-region.js';
+import { LOCAL_NATIVE_PROPERTY_PROFILE } from './property-model.js';
+/** Strategies are source-derived alternatives, without a selected category or target readiness. */
+export function prepareAnalysisRepresentationCandidates(model, profile = LOCAL_NATIVE_PROPERTY_PROFILE) {
+    const common = {
+        identity: cloneJson(model.identity),
+        profileDigest: contentDigest(profile),
+        selectedCandidateId: null,
+    };
+    let result;
+    try {
+        const logicalGraph = prepareLogicalSourceGraph(model);
+        const nodes = new Map(logicalGraph.nodes.map((node) => [node.id, node]));
+        const strategies = [];
+        if (nativeSourceRegion(logicalGraph.rootId, nodes))
+            strategies.push('native');
+        if (logicalGraph.nodes.some((node) => ['record', 'array', 'tuple', 'intersection'].includes(node.kind)))
+            strategies.push('component-model');
+        result = {
+            ...common,
+            status: 'prepared',
+            logicalGraph,
+            candidates: strategies.map((strategy) => ({
+                id: contentDigest({ ...common, source: model.source, strategy }),
+                strategy,
+                requires: 'category-and-representation-decision',
+            })),
+            diagnostics: logicalGraph.coverage === 'complete-within-declared-bound'
+                ? []
+                : ['Source coverage remains bounded or incomplete'],
+        };
+    }
+    catch (error) {
+        result = {
+            ...common,
+            status: 'invalid',
+            candidates: [],
+            diagnostics: [error instanceof Error ? error.message : 'Source graph unavailable'],
+        };
+    }
+    return freezeJson(cloneJson({ ...result, candidateSetHash: contentDigest(result) }));
+}

package/dist/src/property-contract/classification.d.ts

@@ -0,0 +1,38 @@
+import type { CDFFieldDefinition, CDFPropertyDefinition } from '../cdf/types.js';
+import { type JsonValue } from './json-value.js';
+import type { DefaultIntent } from './property-model.js';
+import type { RepresentationProposalDraft } from './representation-proposal.js';
+import type { NullHandlingJudgment } from './null-handling.js';
+export interface ClassifiedPropertyCall {
+    tool: 'classify_prop';
+    prop: string;
+    cdf_type?: string;
+    cdf_category: 'content' | 'design' | 'state';
+    values?: JsonValue[];
+    token_kind?: string;
+    required?: boolean;
+    description?: string;
+    default?: JsonValue;
+    default_intent?: DefaultIntent;
+    items?: CDFFieldDefinition;
+    fields?: Record<string, CDFFieldDefinition>;
+    source_revision?: string;
+    source_node_id?: string;
+    reason?: string;
+    value?: JsonValue;
+    valueType?: CDFFieldDefinition;
+    discriminator?: string;
+    members?: CDFFieldDefinition[];
+    allowedResources?: CDFFieldDefinition['allowedResources'];
+    representation_proposal?: RepresentationProposalDraft;
+    representation_selection?: {
+        strategy: 'component-model';
+        candidateId: string;
+    };
+    null_handling?: NullHandlingJudgment[];
+}
+/** A model selection accounts for the input through a generated slot instead of a native field. */
+export declare function hasPropertyRepresentation(call: ClassifiedPropertyCall): boolean;
+export declare function classificationDefinition(call: ClassifiedPropertyCall): CDFPropertyDefinition;
+export declare function parseClassificationMetadata(rec: Record<string, unknown>, call: ClassifiedPropertyCall): string[];
+export declare function parseClassificationDefaultMetadata(rec: Record<string, unknown>, call: ClassifiedPropertyCall): string[];

package/dist/src/property-contract/classification.js

@@ -0,0 +1,84 @@
+import { validateCDFProperty, targetToCDF } from '../cdf/property-validation.js';
+import { isSourceBoundRepresentation } from './source-representation.js';
+import { cloneJson, own } from './json-value.js';
+/** A model selection accounts for the input through a generated slot instead of a native field. */
+export function hasPropertyRepresentation(call) {
+    return !!call.cdf_type || !!call.representation_selection;
+}
+export function classificationDefinition(call) {
+    if (!call.cdf_type)
+        throw new Error('Absent representation has no field definition');
+    const definition = {
+        ...(call.representation_proposal && isSourceBoundRepresentation(call.cdf_type)
+            ? targetToCDF(call.representation_proposal.desiredDefinition)
+            : {}),
+        $type: call.cdf_type,
+        $category: call.cdf_category,
+    };
+    if (typeof call.required === 'boolean')
+        definition.$required = call.required;
+    if (typeof call.description === 'string')
+        definition.$description = call.description;
+    if (call.items)
+        definition.$items = cloneJson(call.items);
+    if (call.fields)
+        definition.$fields = cloneJson(call.fields);
+    if (own(call, 'value'))
+        definition.value = cloneJson(call.value);
+    if (call.valueType)
+        definition.valueType = cloneJson(call.valueType);
+    if (call.discriminator !== undefined)
+        definition.discriminator = call.discriminator;
+    if (call.members)
+        definition.members = cloneJson(call.members);
+    if (call.allowedResources)
+        definition.allowedResources = cloneJson(call.allowedResources);
+    if (call.values?.length && call.cdf_type !== 'token')
+        definition.$values = cloneJson(call.values);
+    if (call.token_kind && call.cdf_type === 'token')
+        definition['$token.kind'] = call.token_kind;
+    if (own(call, 'default'))
+        definition.$default = cloneJson(call.default);
+    if (call.default_intent?.action === 'set')
+        definition.$default = cloneJson(call.default_intent.value);
+    if (call.default_intent?.action === 'clear')
+        delete definition.$default;
+    return definition;
+}
+export function parseClassificationMetadata(rec, call) {
+    const issues = parseClassificationDefaultMetadata(rec, call);
+    if (own(rec, 'items'))
+        call.items = cloneJson(rec.items);
+    if (own(rec, 'fields'))
+        call.fields = cloneJson(rec.fields);
+    if (own(rec, 'values')) {
+        if (!Array.isArray(rec.values))
+            issues.push('values must be an array');
+        else
+            call.values = cloneJson(rec.values);
+    }
+    if (typeof rec.source_revision === 'string')
+        call.source_revision = rec.source_revision;
+    if (typeof rec.source_node_id === 'string')
+        call.source_node_id = rec.source_node_id;
+    issues.push(...validateCDFProperty(classificationDefinition(call)).issues.map((issue) => `${issue.path}: ${issue.message}`));
+    return issues;
+}
+export function parseClassificationDefaultMetadata(rec, call) {
+    const issues = [];
+    if (own(rec, 'default'))
+        call.default = cloneJson(rec.default);
+    if (own(rec, 'default_intent')) {
+        const intent = rec.default_intent;
+        if (!intent ||
+            typeof intent !== 'object' ||
+            !['absent', 'set', 'clear'].includes(intent.action) ||
+            Object.keys(intent).some((key) => !['action', ...(intent.action === 'set' ? ['value'] : [])].includes(key)) ||
+            (intent.action === 'set' && !own(intent, 'value')) ||
+            own(rec, 'default'))
+            issues.push('Invalid or conflicting default intent');
+        else
+            call.default_intent = cloneJson(intent);
+    }
+    return issues;
+}

package/dist/src/property-contract/compact-model-components.d.ts

@@ -0,0 +1,16 @@
+import type { CDFComponentEntry, CDFSlotDefinition } from '../cdf/types.js';
+import type { LogicalSourceNode } from './logical-source-graph.js';
+import type { LogicalPhysicalMapping } from './representation-plan.js';
+interface GeneratedModel {
+    key: string;
+    nodeId: string;
+    entry: CDFComponentEntry;
+}
+/** Compact physical authoring scaffolding while retaining every logical source node. */
+export declare function compactModelComponents({ nodes, models, mappings, attachment, }: {
+    nodes: ReadonlyMap<string, LogicalSourceNode>;
+    models: Map<string, GeneratedModel>;
+    mappings: Map<string, LogicalPhysicalMapping>;
+    attachment: CDFSlotDefinition;
+}): void;
+export {};