@camstack/types 1.2.405 → 1.2.407

package/dist/composition/customize/event-status.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Assignment status for a pulse feature and a span's camera-sensors
+ * authority (D936, D315, D49). Pending and unreadable are not an empty list.
+ */
+import type { CompositionFieldsFeature, CompositionSourceRef } from '../composition.js';
+import type { CameraSensorAttachment, CameraSensorMode, CameraSensorsStatus } from '../../pipeline/camera-sensors.js';
+import type { CustomizeAssignmentStatus } from './override-draft.js';
+import type { ScalarRead, ScalarSourcePresence } from './scalar-status.js';
+export interface PulseStatusInput {
+    readonly cap: string;
+    readonly targetId: string;
+    readonly device: CompositionSourceRef;
+    readonly timestampPath: string;
+    readonly counterPath: string;
+    readonly apply: 'add' | 'replace';
+    readonly stored: ScalarRead<CompositionFieldsFeature | null>;
+    readonly sourcePresence: ScalarSourcePresence;
+    readonly sourceUnknownReason: string | null;
+}
+export interface PulseAssignmentProjection {
+    readonly text: string;
+    readonly status: CustomizeAssignmentStatus;
+}
+export interface SpanSensorRow {
+    readonly key: string;
+    readonly addonId: string;
+    readonly stableId: string;
+    readonly name: string;
+    readonly mode: CameraSensorMode;
+    readonly state: CameraSensorAttachment['state'];
+    readonly reason: string | null;
+}
+export interface SpanAssignmentProjection {
+    readonly text: string;
+    readonly writable: boolean;
+    readonly rows: readonly SpanSensorRow[];
+    readonly status: CustomizeAssignmentStatus;
+}
+export type SpanRead = {
+    readonly kind: 'pending';
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string | null;
+} | {
+    readonly kind: 'known';
+    readonly value: CameraSensorsStatus;
+};
+export declare function projectPulseAssignment(input: PulseStatusInput): PulseAssignmentProjection;
+export declare function projectSpanAssignment(targetId: string, stored: SpanRead): SpanAssignmentProjection;

package/dist/composition/customize/field-source.d.ts

@@ -0,0 +1,5 @@
+import type { CompositionExpressionSource, CompositionFieldSource, CompositionFromSource, CompositionSourceRef } from '../composition.js';
+export declare function fromRead(source: CompositionSourceRef, cap: string, fieldPath: string): CompositionFromSource;
+export declare function expression(expr: string, bindings: CompositionExpressionSource['bindings']): CompositionFieldSource;
+export declare function literal(expr: string): CompositionFieldSource;
+export declare function isLiteral(source: CompositionFieldSource | undefined, expr: string): boolean;

package/dist/composition/customize/keyed-array-compile.d.ts

@@ -0,0 +1,26 @@
+import { type CompositionFieldsFeature, type CompositionSourceRef } from '../composition.js';
+import type { KeyedArrayOverrideDraft } from './override-draft.js';
+import type { CustomizeRoundTrip } from './stored.js';
+export type KeyedSourceValueKind = 'boolean' | 'number' | 'string' | 'enum';
+export interface KeyedArrayLiteral {
+    readonly path: string;
+    readonly value: string;
+}
+export interface KeyedArrayItemCompile {
+    readonly draft: KeyedArrayOverrideDraft;
+    readonly sourceValueKind: KeyedSourceValueKind;
+    readonly sourceUnit: string | null;
+    readonly literals: readonly KeyedArrayLiteral[];
+}
+export interface KeyedArrayCompileInput {
+    readonly cap: string;
+    readonly targetId: string;
+    readonly device: CompositionSourceRef;
+    readonly apply: 'add' | 'replace';
+    readonly items: readonly KeyedArrayItemCompile[];
+}
+export declare function compileKeyedArrayOverride(input: KeyedArrayCompileInput): CustomizeRoundTrip<CompositionFieldsFeature>;
+/** Put one compiled item into an existing feature. Other items stay as stored. */
+export declare function mergeKeyedArrayItem(current: CompositionFieldsFeature | null, compiled: CompositionFieldsFeature, key: string): CompositionFieldsFeature | null;
+/** The feature without item `key`. Null when that item was the last one. */
+export declare function withoutKeyedArrayItem(feature: CompositionFieldsFeature, key: string): CompositionFieldsFeature | null;

package/dist/composition/customize/keyed-array-decode.d.ts

@@ -0,0 +1,20 @@
+import type { CompositionFieldsFeature, CompositionSourceRef } from '../composition.js';
+import { type KeyedArrayItemCompile } from './keyed-array-compile.js';
+export interface KeyedArrayItemView {
+    readonly key: string;
+    readonly label: string;
+    readonly recognized: boolean;
+    readonly compile: KeyedArrayItemCompile | null;
+}
+export interface KeyedArrayRead {
+    readonly canonical: boolean;
+    readonly apply: 'add' | 'replace';
+    readonly items: readonly KeyedArrayItemView[];
+}
+export declare function readKeyedArrayItems(feature: CompositionFieldsFeature, cap: string, targetId: string): KeyedArrayRead | null;
+export declare function decodeKeyedArrayOverride(input: {
+    readonly feature: CompositionFieldsFeature;
+    readonly device: CompositionSourceRef;
+    readonly cap: string;
+    readonly targetId: string;
+}): KeyedArrayRead | null;

package/dist/composition/customize/keyed-array-expr.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonical expression text for one keyed-array transform. The decoder reads
+ * only this spelling.
+ */
+import type { CustomizeTransformDraft } from './override-draft.js';
+export declare function enumMapExpr(mapping: Readonly<Record<string, string | null>>): string | null;
+export declare function parseEnumMap(expr: string): Readonly<Record<string, string | null>> | null;
+export declare function enumMapDraft(mapping: Readonly<Record<string, string | null>>): Extract<CustomizeTransformDraft, {
+    kind: 'enum-map';
+}>;

package/dist/composition/customize/keyed-array-status.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Assignment-status projection for one keyed-array target (D936). Pending and
+ * unknown are unanswered reads. A confirmed-gone source leaves an added array
+ * assigned: the native rows are a different authority.
+ */
+import type { CompositionFieldsFeature, CompositionSourceRef } from '../composition.js';
+import type { CustomizeAssignmentStatus } from './override-draft.js';
+import type { ScalarRead, ScalarSourcePresence } from './scalar-status.js';
+export interface KeyedArrayStatusInput {
+    readonly cap: string;
+    readonly targetId: string;
+    readonly device: CompositionSourceRef;
+    readonly stored: ScalarRead<CompositionFieldsFeature | null>;
+    readonly sourcePresence: ScalarSourcePresence;
+    readonly sourceUnknownReason: string | null;
+}
+export interface KeyedArrayAssignmentProjection {
+    readonly text: string;
+    readonly assignedCount: number;
+    readonly status: CustomizeAssignmentStatus;
+}
+export declare function projectKeyedArrayAssignment(input: KeyedArrayStatusInput): KeyedArrayAssignmentProjection;

package/dist/composition/customize/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { CustomizeStored } from './stored.js';
+/** Key order is not part of the stored contract. Array order is. */
+export declare function normalizeStored(stored: CustomizeStored): unknown;
+export declare function sameStored(a: CustomizeStored, b: CustomizeStored): boolean;

package/dist/composition/customize/override-draft.d.ts

@@ -0,0 +1,311 @@
+/**
+ * A saved Customize assignment (D936). The schema is the type: callers use
+ * `z.infer`, they do not restate the shape.
+ */
+import { z } from 'zod';
+export declare const OverrideSourceSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    stableId: z.ZodString;
+    cap: z.ZodString;
+    fieldPath: z.ZodString;
+}, z.core.$strip>;
+export type OverrideSource = z.infer<typeof OverrideSourceSchema>;
+export declare const IdentityTransformDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"identity">;
+}, z.core.$strip>;
+export declare const InvertTransformDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"invert">;
+}, z.core.$strip>;
+export declare const ThresholdTransformDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"threshold">;
+    comparison: z.ZodEnum<{
+        gte: "gte";
+        lte: "lte";
+    }>;
+    threshold: z.ZodNumber;
+    startDwellMs: z.ZodNumber;
+    stopDwellMs: z.ZodNumber;
+}, z.core.$strip>;
+export declare const LinearTransformDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"linear">;
+    scale: z.ZodNumber;
+    offset: z.ZodNumber;
+    clampMin: z.ZodOptional<z.ZodNumber>;
+    clampMax: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const EnumMapTransformDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"enum-map">;
+    mapping: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const NumberBridgeTransformDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"number">;
+}, z.core.$strip>;
+export declare const CustomizeTransformDraftSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"identity">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"invert">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"threshold">;
+    comparison: z.ZodEnum<{
+        gte: "gte";
+        lte: "lte";
+    }>;
+    threshold: z.ZodNumber;
+    startDwellMs: z.ZodNumber;
+    stopDwellMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"linear">;
+    scale: z.ZodNumber;
+    offset: z.ZodNumber;
+    clampMin: z.ZodOptional<z.ZodNumber>;
+    clampMax: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"enum-map">;
+    mapping: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"number">;
+}, z.core.$strip>], "kind">;
+export type CustomizeTransformDraft = z.infer<typeof CustomizeTransformDraftSchema>;
+export declare const ScalarOverrideDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"scalar">;
+    cap: z.ZodString;
+    targetId: z.ZodString;
+    source: z.ZodObject<{
+        addonId: z.ZodString;
+        stableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>;
+    transform: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"identity">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"invert">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"threshold">;
+        comparison: z.ZodEnum<{
+            gte: "gte";
+            lte: "lte";
+        }>;
+        threshold: z.ZodNumber;
+        startDwellMs: z.ZodNumber;
+        stopDwellMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"linear">;
+        scale: z.ZodNumber;
+        offset: z.ZodNumber;
+        clampMin: z.ZodOptional<z.ZodNumber>;
+        clampMax: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"enum-map">;
+        mapping: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"number">;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export type ScalarOverrideDraft = z.infer<typeof ScalarOverrideDraftSchema>;
+export declare const KeyedArrayOverrideDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"keyedArray">;
+    cap: z.ZodString;
+    targetId: z.ZodString;
+    key: z.ZodString;
+    label: z.ZodString;
+    fieldPath: z.ZodString;
+    source: z.ZodObject<{
+        addonId: z.ZodString;
+        stableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>;
+    transform: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"identity">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"invert">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"threshold">;
+        comparison: z.ZodEnum<{
+            gte: "gte";
+            lte: "lte";
+        }>;
+        threshold: z.ZodNumber;
+        startDwellMs: z.ZodNumber;
+        stopDwellMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"linear">;
+        scale: z.ZodNumber;
+        offset: z.ZodNumber;
+        clampMin: z.ZodOptional<z.ZodNumber>;
+        clampMax: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"enum-map">;
+        mapping: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"number">;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+export type KeyedArrayOverrideDraft = z.infer<typeof KeyedArrayOverrideDraftSchema>;
+export declare const PulseOverrideDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"pulse">;
+    cap: z.ZodString;
+    targetId: z.ZodString;
+    enabled: z.ZodBoolean;
+    debounceMs: z.ZodNumber;
+    sources: z.ZodArray<z.ZodObject<{
+        addonId: z.ZodString;
+        stableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PulseOverrideDraft = z.infer<typeof PulseOverrideDraftSchema>;
+export declare const SpanSourceDraftSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    stableId: z.ZodString;
+    cap: z.ZodString;
+    fieldPath: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        confirm: "confirm";
+        "in-addition": "in-addition";
+        replace: "replace";
+    }>>;
+}, z.core.$strip>;
+export type SpanSourceDraft = z.infer<typeof SpanSourceDraftSchema>;
+export declare const SpanOverrideDraftSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"span">;
+    cap: z.ZodString;
+    targetId: z.ZodString;
+    timeoutMs: z.ZodNumber;
+    cooldownMs: z.ZodOptional<z.ZodNumber>;
+    sources: z.ZodArray<z.ZodObject<{
+        addonId: z.ZodString;
+        stableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
+            confirm: "confirm";
+            "in-addition": "in-addition";
+            replace: "replace";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SpanOverrideDraft = z.infer<typeof SpanOverrideDraftSchema>;
+export declare const OverrideDraftSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"scalar">;
+    cap: z.ZodString;
+    targetId: z.ZodString;
+    source: z.ZodObject<{
+        addonId: z.ZodString;
+        stableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>;
+    transform: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"identity">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"invert">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"threshold">;
+        comparison: z.ZodEnum<{
+            gte: "gte";
+            lte: "lte";
+        }>;
+        threshold: z.ZodNumber;
+        startDwellMs: z.ZodNumber;
+        stopDwellMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"linear">;
+        scale: z.ZodNumber;
+        offset: z.ZodNumber;
+        clampMin: z.ZodOptional<z.ZodNumber>;
+        clampMax: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"enum-map">;
+        mapping: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"number">;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"keyedArray">;
+    cap: z.ZodString;
+    targetId: z.ZodString;
+    key: z.ZodString;
+    label: z.ZodString;
+    fieldPath: z.ZodString;
+    source: z.ZodObject<{
+        addonId: z.ZodString;
+        stableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>;
+    transform: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"identity">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"invert">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"threshold">;
+        comparison: z.ZodEnum<{
+            gte: "gte";
+            lte: "lte";
+        }>;
+        threshold: z.ZodNumber;
+        startDwellMs: z.ZodNumber;
+        stopDwellMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"linear">;
+        scale: z.ZodNumber;
+        offset: z.ZodNumber;
+        clampMin: z.ZodOptional<z.ZodNumber>;
+        clampMax: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"enum-map">;
+        mapping: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"number">;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"pulse">;
+    cap: z.ZodString;
+    targetId: z.ZodString;
+    enabled: z.ZodBoolean;
+    debounceMs: z.ZodNumber;
+    sources: z.ZodArray<z.ZodObject<{
+        addonId: z.ZodString;
+        stableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"span">;
+    cap: z.ZodString;
+    targetId: z.ZodString;
+    timeoutMs: z.ZodNumber;
+    cooldownMs: z.ZodOptional<z.ZodNumber>;
+    sources: z.ZodArray<z.ZodObject<{
+        addonId: z.ZodString;
+        stableId: z.ZodString;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
+            confirm: "confirm";
+            "in-addition": "in-addition";
+            replace: "replace";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+export type OverrideDraft = z.infer<typeof OverrideDraftSchema>;
+/** Effective authority for one declared target. Not a second stored switch. */
+export declare const CustomizeAssignmentStatusSchema: z.ZodObject<{
+    targetId: z.ZodString;
+    configured: z.ZodBoolean;
+    source: z.ZodEnum<{
+        assigned: "assigned";
+        native: "native";
+    }>;
+    state: z.ZodEnum<{
+        active: "active";
+        released: "released";
+        stale: "stale";
+        unavailable: "unavailable";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CustomizeAssignmentStatus = z.infer<typeof CustomizeAssignmentStatusSchema>;

package/dist/composition/customize/scalar-compile.d.ts

@@ -0,0 +1,13 @@
+import type { CompositionFieldsFeature, CompositionSourceRef } from '../composition.js';
+import type { ScalarOverrideDraft } from './override-draft.js';
+import type { CustomizeRoundTrip } from './stored.js';
+export type ScalarValueKind = 'boolean' | 'number' | 'string';
+export interface ScalarCompileInput {
+    readonly draft: ScalarOverrideDraft;
+    readonly device: CompositionSourceRef;
+    readonly apply: 'add' | 'replace';
+    readonly sourceValueKind: ScalarValueKind;
+    readonly changedAtField: string | null;
+    readonly sourceUnit: string | null;
+}
+export declare function compileScalarOverride(input: ScalarCompileInput): CustomizeRoundTrip<CompositionFieldsFeature>;

package/dist/composition/customize/scalar-decode.d.ts

@@ -0,0 +1,17 @@
+import type { CompositionFieldsFeature, CompositionSourceRef } from '../composition.js';
+import type { ScalarOverrideDraft } from './override-draft.js';
+import { type ScalarValueKind } from './scalar-compile.js';
+export interface ScalarDecoded {
+    readonly draft: ScalarOverrideDraft;
+    readonly apply: 'add' | 'replace';
+    readonly sourceValueKind: ScalarValueKind;
+    readonly changedAtField: string | null;
+    readonly sourceUnit: string | null;
+}
+export interface ScalarDecodeInput {
+    readonly feature: CompositionFieldsFeature;
+    readonly device: CompositionSourceRef;
+    readonly cap: string;
+    readonly targetId: string;
+}
+export declare function decodeScalarOverride(input: ScalarDecodeInput): ScalarDecoded | null;

package/dist/composition/customize/scalar-expr.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Canonical expression text for one scalar transform. The decoder reads only
+ * this spelling, so a stored row from the current builders still matches.
+ */
+import type { CompositionFieldSource } from '../composition.js';
+export declare function unsignedToken(value: number): string | null;
+export declare function signedToken(value: number): string | null;
+export declare function constantExpr(value: string | number | boolean | null): string | null;
+export declare function isIdentifier(path: string): boolean;
+export declare function dwellExpr(comparison: 'gte' | 'lte', threshold: string, start: string, stop: string): string;
+export declare function linearExpr(inner: 'x' | 'number(x)', scale: string, offset: string, clampMin: string | null, clampMax: string | null): string;
+export interface ParsedDwell {
+    readonly comparison: 'gte' | 'lte';
+    readonly threshold: number;
+    readonly startDwellMs: number;
+    readonly stopDwellMs: number;
+}
+export declare function parseDwell(expr: string): ParsedDwell | null;
+export interface ParsedLinear {
+    readonly inner: 'x' | 'number(x)';
+    readonly scale: number;
+    readonly offset: number;
+    readonly clampMin?: number;
+    readonly clampMax?: number;
+}
+export declare function parseLinear(expr: string): ParsedLinear | null;
+export interface BoundRead {
+    readonly cap: string;
+    readonly fieldPath: string;
+    readonly addonId: string;
+    readonly stableId: string;
+}
+export declare function singleFrom(source: CompositionFieldSource): BoundRead | null;

package/dist/composition/customize/scalar-status.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Assignment-status projection for one scalar target (D936, D315, D393).
+ * Pending and unknown are unanswered reads. A failed read never becomes 0.
+ * A confirmed-gone source releases a replacement to native and leaves an
+ * added field assigned.
+ */
+import type { CompositionFieldsFeature, CompositionSourceRef } from '../composition.js';
+import type { CustomizeAssignmentStatus } from './override-draft.js';
+export type ScalarRead<T> = {
+    readonly kind: 'pending';
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string | null;
+} | {
+    readonly kind: 'known';
+    readonly value: T;
+};
+export type ScalarSourcePresence = 'pending' | 'present' | 'absent' | 'unknown';
+export interface ScalarStatusInput {
+    readonly cap: string;
+    readonly targetId: string;
+    readonly device: CompositionSourceRef;
+    readonly stored: ScalarRead<CompositionFieldsFeature | null>;
+    readonly sourcePresence: ScalarSourcePresence;
+    readonly sourceUnknownReason: string | null;
+}
+export interface ScalarAssignmentProjection {
+    readonly text: string;
+    readonly status: CustomizeAssignmentStatus;
+}
+export declare function projectScalarAssignment(input: ScalarStatusInput): ScalarAssignmentProjection;

package/dist/composition/customize/stored.d.ts

@@ -0,0 +1,15 @@
+import type { CompositionFieldsFeature, CompositionSourceRef } from '../composition.js';
+/** A composition claim. `target` is the device the feature lands on. */
+export interface CompositionCustomizeStored {
+    readonly family: 'composition';
+    readonly target: CompositionSourceRef;
+    readonly feature: CompositionFieldsFeature;
+}
+export type CustomizeStored = CompositionCustomizeStored;
+export type CustomizeRoundTrip<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};

package/dist/composition/index.d.ts

@@ -11,7 +11,6 @@ export * from './composition-report.js';
 export * from './evaluate-field.js';
 export * from './examples.js';
 export * from './expression-kinds.js';
-export * from './presets/doorbell-feature.js';
 export * from './presets/numeric-transforms.js';
 export * from './state-fields.js';
 export * from './validate-composition.js';