@camstack/types 1.2.417 → 1.2.419

package/dist/composition/helpers/actuator.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Actuator groups (D944 phase 1b). The active boolean is the binary reducer
+ * with unknown members left out. A command is one call per member that binds
+ * the cap, including members that are offline. One failure does not cancel
+ * the others.
+ */
+import { DeviceFeature } from '../../device/device-type.js';
+import type { ActiveCriterion, BinaryAggregate } from './spec.js';
+/** Caps a light group may expose, in display order. Switch is the active state. */
+export declare const LIGHT_SHARED_CAPS: readonly ['switch', 'brightness', 'color'];
+export type LightSharedCap = (typeof LIGHT_SHARED_CAPS)[number];
+/** How many member calls run at once. The rest wait; none are dropped. */
+export declare const FAN_OUT_CONCURRENCY: number;
+export interface FanOutMember {
+    readonly deviceId: number;
+    readonly caps: readonly string[];
+    /** Offline members are still commanded — they may wake. Not a reason to skip. */
+    readonly online: boolean;
+}
+export interface FanOutCall {
+    readonly deviceId: number;
+    readonly cap: string;
+    readonly method: string;
+    readonly args: Readonly<Record<string, unknown>>;
+}
+export interface FanOutOk {
+    readonly deviceId: number;
+    readonly ok: true;
+}
+export interface FanOutFailed {
+    readonly deviceId: number;
+    readonly ok: false;
+    readonly error: string;
+}
+export type FanOutMemberResult = FanOutOk | FanOutFailed;
+/** `at-least-one` is any included member on; `all` is every included member on. */
+export declare function reducerForActive(active: ActiveCriterion): BinaryAggregate;
+export declare function activeForReducer(reducer: BinaryAggregate): ActiveCriterion;
+/**
+ * Caps every member binds, from {@link LIGHT_SHARED_CAPS}. An empty member
+ * list shares nothing. A member that lacks colour drops colour from the group.
+ */
+export declare function sharedLightCaps(memberCaps: readonly (readonly string[])[]): readonly string[];
+/**
+ * Colour modes every member advertises. Offline does not remove a mode:
+ * the caller passes device features, not liveness. No members → no mode.
+ */
+export declare function sharedColorModes(memberFeatures: readonly (readonly string[])[]): readonly DeviceFeature[];
+/**
+ * One call per member that binds `cap`. Offline members stay in the list.
+ * A member without the cap is not called — the command cannot reach it.
+ */
+export declare function fanOutTargets(members: readonly FanOutMember[], cap: string, method: string, args: Readonly<Record<string, unknown>>): readonly FanOutCall[];
+/**
+ * Run every call. A throw is that member's result; the other calls still run.
+ * At most {@link FAN_OUT_CONCURRENCY} are in flight.
+ */
+export declare function runFanOut(calls: readonly FanOutCall[], invoke: (call: FanOutCall) => Promise<void>): Promise<readonly FanOutMemberResult[]>;

package/dist/composition/helpers/aggregate.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A group reducer (D944). Offline and unknown members are excluded and
+ * counted. They are never passed in as 0 or false (D393). A free expression
+ * does not use this — `avg` / `any` still include a stale value.
+ */
+import type { ExpressionValue } from '../../expression/ast.js';
+import type { AggregateReducer } from './spec.js';
+export interface AggregateReadResult {
+    readonly state: 'fresh' | 'stale' | 'unavailable';
+    readonly value?: ExpressionValue;
+    /** Set when `state` is `unavailable` and the source is gone. */
+    readonly fatal?: boolean;
+    readonly reason?: string;
+}
+export interface AggregateCounts {
+    readonly included: number;
+    readonly excluded: number;
+    readonly total: number;
+}
+export type AggregatePublish = 'value' | 'included' | 'excluded' | 'total';
+export type AggregateEmpty = 'null' | 'omit' | 'offline';
+export interface EvaluateAggregateInput {
+    readonly reducer: AggregateReducer;
+    readonly members: readonly AggregateReadResult[];
+    readonly publish: AggregatePublish;
+    readonly empty: AggregateEmpty;
+}
+export interface AggregateValue {
+    readonly kind: 'value';
+    readonly value: number | boolean | null;
+    readonly counts: AggregateCounts;
+}
+export interface AggregateUnavailable {
+    readonly kind: 'unavailable';
+    readonly fatal: boolean;
+    readonly reason: string;
+    readonly counts: AggregateCounts;
+}
+export type AggregateOutcome = AggregateValue | AggregateUnavailable;
+/** Pure. `members` is not mutated. An empty included set is null or unavailable, never 0 or false. */
+export declare function evaluateAggregate(input: EvaluateAggregateInput): AggregateOutcome;

package/dist/composition/helpers/catalog.d.ts

@@ -0,0 +1,47 @@
+/**
+ * One catalog row per base reading a group helper can build (D944 §3).
+ * Data, not a form default written into the block.
+ */
+import { DeviceRole, DeviceType } from '../../device/device-type.js';
+import { type ReadingQuantity } from '../../units/quantity.js';
+import type { AggregateEmpty } from './aggregate.js';
+import { type AggregateReducer, type GroupTemplateId } from './spec.js';
+export interface HelperAccept {
+    readonly cap: string;
+    readonly fieldPath: string;
+}
+export interface HelperCompanion {
+    readonly fieldPath: string;
+    readonly expr: string;
+}
+export interface GroupTemplate {
+    readonly id: GroupTemplateId;
+    readonly family: 'numeric' | 'binary' | 'actuator';
+    readonly summary: string;
+    readonly deviceType: DeviceType;
+    readonly role: DeviceRole | undefined;
+    /** Members are this one device type. */
+    readonly memberDeviceType: DeviceType;
+    readonly outputCap: string;
+    readonly outputField: string;
+    /**
+     * Methods the composer fans out. Empty for a reading. A free composition
+     * still cannot serve these caps (`has-commands`).
+     */
+    readonly commandCaps: readonly string[];
+    /** Quantity of the output reading. `device` is chosen per numeric sensor. */
+    readonly quantity: ReadingQuantity;
+    readonly baseUnit: string | undefined;
+    readonly aggregates: readonly AggregateReducer[];
+    readonly defaultAggregate: AggregateReducer;
+    /**
+     * No included member: `null` writes null and stays online; `omit` leaves an
+     * optional key out and stays online; `offline` takes the device offline
+     * rather than publishing false (D393).
+     */
+    readonly empty: AggregateEmpty;
+    readonly accept: readonly HelperAccept[];
+    readonly companions: readonly HelperCompanion[];
+}
+export declare const GROUP_TEMPLATES: readonly GroupTemplate[];
+export declare function groupTemplate(id: GroupTemplateId): GroupTemplate | null;

package/dist/composition/helpers/compile.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Project a helper spec onto the composition the composer already runs (D944).
+ * Pure: it stores nothing. A group does not compile to `avg(...)` / `any(...)`.
+ */
+import { DeviceType } from '../../device/device-type.js';
+import { type Composition } from '../composition.js';
+import type { CompositionProblem } from '../composition-report.js';
+import { type HelperSpec } from './spec.js';
+export interface HelperCompiled {
+    readonly ok: true;
+    readonly composition: Composition;
+}
+export interface HelperRefused {
+    readonly ok: false;
+    readonly problems: readonly CompositionProblem[];
+}
+export type HelperCompileResult = HelperCompiled | HelperRefused;
+/** Compile a group template to a new-device composition. Refusals are named. */
+export declare function compileHelper(spec: HelperSpec): HelperCompileResult;
+/** The built body, ignoring `helper`, so a save can demand one writer. */
+export declare function sameHelperBody(stored: Composition, compiled: Composition): boolean;
+export declare function templateDeviceType(spec: HelperSpec): DeviceType | null;

package/dist/composition/helpers/index.d.ts

@@ -0,0 +1,7 @@
+export { FAN_OUT_CONCURRENCY, LIGHT_SHARED_CAPS, type FanOutCall, type FanOutFailed, type FanOutMember, type FanOutMemberResult, type FanOutOk, type LightSharedCap, activeForReducer, fanOutTargets, reducerForActive, runFanOut, sharedColorModes, sharedLightCaps, } from './actuator.js';
+export { type AggregateCounts, type AggregateEmpty, type AggregateOutcome, type AggregatePublish, type AggregateReadResult, type AggregateUnavailable, type AggregateValue, type EvaluateAggregateInput, evaluateAggregate, } from './aggregate.js';
+export { type GroupTemplate, type HelperAccept, type HelperCompanion, GROUP_TEMPLATES, groupTemplate, } from './catalog.js';
+export { type HelperCompileResult, type HelperCompiled, type HelperRefused, compileHelper, sameHelperBody, templateDeviceType, } from './compile.js';
+export { type HelperMemberFact, helperSaveProblems, } from './save.js';
+export { type SourcePick, type SourcePickAccept, type SourcePickHistory, type SourcePickRequest, sourcePickForTemplate, } from './source-pick.js';
+export { ACTIVE_CRITERIA, AGGREGATE_REDUCERS, ActiveCriterionSchema, AggregateReducerSchema, BINARY_AGGREGATES, GROUP_TEMPLATE_IDS, GroupHelperSpecSchema, GroupTemplateIdSchema, HelperMemberSchema, HelperSpecSchema, MAX_HELPER_MEMBERS, NUMERIC_AGGREGATES, type ActiveCriterion, type AggregateReducer, type BinaryAggregate, type GroupHelperSpec, type GroupTemplateId, type HelperMember, type HelperSpec, type NumericAggregate, } from './spec.js';

package/dist/composition/helpers/save.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Save-time checks a pure compile cannot make: the compiled features must be
+ * this spec's, and members that report a quantity must share one (D944 §4).
+ */
+import type { DeviceType } from '../../device/device-type.js';
+import type { ReadingQuantity } from '../../units/quantity.js';
+import { type Composition } from '../composition.js';
+import type { CompositionProblem } from '../composition-report.js';
+/** What a save learned about one member device. Absent keys were not read. */
+export interface HelperMemberFact {
+    readonly deviceType?: DeviceType;
+    readonly quantity?: ReadingQuantity;
+}
+/**
+ * Problems that refuse a save. No `helper` key means a free composition: this
+ * returns nothing, and expression semantics stay as they are.
+ */
+export declare function helperSaveProblems(composition: Composition, facts: ReadonlyMap<string, HelperMemberFact>): readonly CompositionProblem[];

package/dist/composition/helpers/source-pick.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The request the common source selector (#236) accepts for a helper (D944 §5).
+ * The selector's layout is not specified here. Groups ask for one device type
+ * and the catalog field; they do not opt into incompatible fields.
+ */
+import type { DeviceType } from '../../device/device-type.js';
+import type { CompositionSourceRef } from '../source-ref.js';
+import type { GroupTemplate } from './catalog.js';
+export interface SourcePickAccept {
+    readonly cap: string;
+    readonly fieldPath: string;
+    readonly valueKind: 'number' | 'boolean';
+}
+export interface SourcePickHistory {
+    readonly required: boolean;
+    readonly minRetentionMs: number | null;
+}
+export interface SourcePickRequest {
+    readonly purpose: 'member' | 'reading' | 'historised';
+    readonly multiple: boolean;
+    readonly max: number;
+    readonly deviceTypes: readonly DeviceType[];
+    readonly accept: readonly SourcePickAccept[];
+    readonly history: SourcePickHistory;
+    readonly mustBindCaps: readonly string[];
+    readonly exclude: readonly CompositionSourceRef[];
+}
+export interface SourcePick {
+    readonly source: CompositionSourceRef;
+    readonly deviceId: number;
+    readonly parentName: string | null;
+    readonly cap: string;
+    readonly fieldPath: string;
+    /** Current reading. `null` is unknown, never a stand-in 0. */
+    readonly current: number | boolean | string | null;
+    readonly compatibility: 'direct' | 'convert' | 'incompatible';
+    readonly history: 'recorded' | 'absent' | 'unknown';
+}
+/** What the member step asks the selector for this template. */
+export declare function sourcePickForTemplate(template: GroupTemplate): SourcePickRequest;

package/dist/composition/helpers/spec.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A helper spec is what the editor stores and reads back (D944). The compiled
+ * features are a projection; the editor never edits the expression.
+ */
+import { z } from 'zod';
+import { CompositionSourceRefSchema } from '../source-ref.js';
+/** A group may name more members than an expression call (the 16-arg cap). */
+export declare const MAX_HELPER_MEMBERS: number;
+export declare const GROUP_TEMPLATE_IDS: readonly ['temperature', 'humidity', 'pressure', 'illuminance', 'power', 'energy', 'battery', 'numeric', 'motion', 'contact', 'leak', 'smoke', 'occupancy', 'binary', 'switch', 'light'];
+export type GroupTemplateId = (typeof GROUP_TEMPLATE_IDS)[number];
+export declare const NUMERIC_AGGREGATES: readonly ['mean', 'median', 'min', 'max', 'sum'];
+export type NumericAggregate = (typeof NUMERIC_AGGREGATES)[number];
+export declare const BINARY_AGGREGATES: readonly ['any', 'all'];
+export type BinaryAggregate = (typeof BINARY_AGGREGATES)[number];
+/** How an actuator group decides it is on. Unknown members never count as off. */
+export declare const ACTIVE_CRITERIA: readonly ['at-least-one', 'all'];
+export type ActiveCriterion = (typeof ACTIVE_CRITERIA)[number];
+export declare const AGGREGATE_REDUCERS: readonly ['mean', 'median', 'min', 'max', 'sum', 'any', 'all'];
+export type AggregateReducer = (typeof AGGREGATE_REDUCERS)[number];
+export declare const GroupTemplateIdSchema: z.ZodType<GroupTemplateId>;
+export declare const AggregateReducerSchema: z.ZodType<AggregateReducer>;
+export declare const ActiveCriterionSchema: z.ZodType<ActiveCriterion>;
+/** One member. The field is stored so occupancy can name motion or binary. */
+export declare const HelperMemberSchema: z.ZodObject<{
+    source: typeof CompositionSourceRefSchema;
+    cap: z.ZodString;
+    fieldPath: z.ZodString;
+}>;
+export type HelperMember = z.infer<typeof HelperMemberSchema>;
+/**
+ * Phase 1a is groups only. Math, integral and statistics stay off this union
+ * until the composer can run them — a control must not save a spec it cannot.
+ */
+export declare const GroupHelperSpecSchema: z.ZodObject<{
+    kind: z.ZodLiteral<'group'>;
+    templateId: typeof GroupTemplateIdSchema;
+    aggregate: typeof AggregateReducerSchema;
+    members: z.ZodArray<typeof HelperMemberSchema>;
+    active: z.ZodOptional<typeof ActiveCriterionSchema>;
+}>;
+export type GroupHelperSpec = z.infer<typeof GroupHelperSpecSchema>;
+export declare const HelperSpecSchema: z.ZodDiscriminatedUnion<[typeof GroupHelperSpecSchema], 'kind'>;
+export type HelperSpec = z.infer<typeof HelperSpecSchema>;

package/dist/composition/index.d.ts

@@ -3,6 +3,7 @@
  * inside @camstack/types import the deep modules, never this file.
  */
 export * from './composable-caps.js';
+export * from './helpers/index.js';
 export * from './composition.js';
 export * from './composition-events.js';
 export * from './composition-graph.js';

package/dist/composition/source-ref.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A composition source identity: `(addonId, stableId)`, never a numeric device
+ * id. Split out so helper schemas can name it without a cycle through
+ * `composition.ts` (D659).
+ */
+import { z } from 'zod';
+export declare const CompositionSourceRefSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    stableId: z.ZodString;
+}>;
+export type CompositionSourceRef = z.infer<typeof CompositionSourceRefSchema>;

package/dist/composition/validate-composition.d.ts

@@ -10,6 +10,7 @@
  */
 import type { CapabilityDefinition } from '../capabilities/capability-definition.js';
 import type { DeviceType } from '../device/device-type.js';
+import type { ReadingQuantity } from '../units/quantity.js';
 import { type Composition, type CompositionSourceRef } from './composition.js';
 import { type CompositionPlanResult } from './plan-result.js';
 import { type CompositionPeer } from './composition-graph.js';
@@ -22,6 +23,10 @@ export interface CompositionSourceFound {
     readonly kind: 'found';
     readonly deviceId: number;
     readonly caps: ReadonlySet<string>;
+    /** Present when the row was read. A helper group requires this one type. */
+    readonly deviceType?: DeviceType;
+    /** Present when the device declares one. Mixed quantities are refused. */
+    readonly quantity?: ReadingQuantity;
 }
 export interface CompositionSourceAbsent {
     readonly kind: 'absent';

package/dist/{composition-kEl9mevu.mjs → composition-OhpuespA.mjs}

@@ -2160,6 +2160,85 @@ function evaluateExpressionSource(expr, bindingValues, now, opts) {
 	}
 }
 //#endregion
+//#region src/composition/source-ref.ts
+/**
+* A composition source identity: `(addonId, stableId)`, never a numeric device
+* id. Split out so helper schemas can name it without a cycle through
+* `composition.ts` (D659).
+*/
+var CompositionSourceRefSchema = z.object({
+	/** The owning addon; `stableId` is unique only within it. */
+	addonId: z.string().min(1),
+	stableId: z.string().min(1)
+});
+//#endregion
+//#region src/composition/helpers/spec.ts
+/**
+* A helper spec is what the editor stores and reads back (D944). The compiled
+* features are a projection; the editor never edits the expression.
+*/
+/** A group may name more members than an expression call (the 16-arg cap). */
+var MAX_HELPER_MEMBERS = 64;
+var GROUP_TEMPLATE_IDS = [
+	"temperature",
+	"humidity",
+	"pressure",
+	"illuminance",
+	"power",
+	"energy",
+	"battery",
+	"numeric",
+	"motion",
+	"contact",
+	"leak",
+	"smoke",
+	"occupancy",
+	"binary",
+	"switch",
+	"light"
+];
+var NUMERIC_AGGREGATES = [
+	"mean",
+	"median",
+	"min",
+	"max",
+	"sum"
+];
+var BINARY_AGGREGATES = ["any", "all"];
+/** How an actuator group decides it is on. Unknown members never count as off. */
+var ACTIVE_CRITERIA = ["at-least-one", "all"];
+var AGGREGATE_REDUCERS = [
+	"mean",
+	"median",
+	"min",
+	"max",
+	"sum",
+	"any",
+	"all"
+];
+var GroupTemplateIdSchema = z.enum(GROUP_TEMPLATE_IDS);
+var AggregateReducerSchema = z.enum(AGGREGATE_REDUCERS);
+var ActiveCriterionSchema = z.enum(ACTIVE_CRITERIA);
+/** One member. The field is stored so occupancy can name motion or binary. */
+var HelperMemberSchema = z.object({
+	source: CompositionSourceRefSchema,
+	cap: z.string().min(1),
+	fieldPath: z.string().min(1)
+});
+/**
+* Phase 1a is groups only. Math, integral and statistics stay off this union
+* until the composer can run them — a control must not save a spec it cannot.
+*/
+var GroupHelperSpecSchema = z.object({
+	kind: z.literal("group"),
+	templateId: GroupTemplateIdSchema,
+	aggregate: AggregateReducerSchema,
+	members: z.array(HelperMemberSchema).min(1).max(64),
+	/** Actuator groups only. Readings leave this unset. */
+	active: ActiveCriterionSchema.optional()
+});
+var HelperSpecSchema = z.discriminatedUnion("kind", [GroupHelperSpecSchema]);
+//#endregion
 //#region src/composition/composition.ts
 /**
 * A COMPOSITION: a device assembled from other devices' state (D659).
@@ -2195,11 +2274,6 @@ var MAX_COMPOSITION_FEATURES = 16;
 var MAX_COMPOSITION_FIELDS_PER_FEATURE = 32;
 /** Longest snippet a `code` source may carry (slice 4). */
 var MAX_COMPOSITION_CODE_LENGTH = 2e4;
-var CompositionSourceRefSchema = z.object({
-	/** The owning addon; `stableId` is unique only within it. */
-	addonId: z.string().min(1),
-	stableId: z.string().min(1)
-});
 /** One field of one capability of one source device. */
 var CompositionFieldReadSchema = z.object({
 	source: CompositionSourceRefSchema,
@@ -2242,10 +2316,42 @@ var CompositionCodeSourceSchema = z.object({
 	kind: z.literal("code"),
 	code: z.string().min(1).max(MAX_COMPOSITION_CODE_LENGTH)
 });
+/**
+* `aggregate`: a group reducer. Offline and unknown reads are excluded, not
+* folded in as 0 or false (D944). Free expressions stay `expression` so a
+* stale member is still included there.
+*/
+var CompositionAggregateSourceSchema = z.object({
+	kind: z.literal("aggregate"),
+	reducer: z.enum([
+		"mean",
+		"median",
+		"min",
+		"max",
+		"sum",
+		"any",
+		"all"
+	]),
+	reads: z.array(CompositionFieldReadSchema).min(1).max(64),
+	/** `value` is the reading; the others are the member counts. */
+	publish: z.enum([
+		"value",
+		"included",
+		"excluded",
+		"total"
+	]),
+	/** What a `value` publish does when nobody is included. Counts ignore this. */
+	empty: z.enum([
+		"null",
+		"omit",
+		"offline"
+	])
+});
 var CompositionFieldSourceSchema = z.discriminatedUnion("kind", [
 	CompositionFromSourceSchema,
 	CompositionExpressionSourceSchema,
-	CompositionCodeSourceSchema
+	CompositionCodeSourceSchema,
+	CompositionAggregateSourceSchema
 ]);
 /** `forward`: RESERVED for slice 3. Argument mapping arrives there as an additive optional `args`. */
 var CompositionForwardCommandSchema = z.object({
@@ -2311,7 +2417,13 @@ var CompositionExistingTargetSchema = z.object({
 var CompositionTargetSchema = z.discriminatedUnion("kind", [CompositionNewTargetSchema, CompositionExistingTargetSchema]);
 var CompositionSchema = z.object({
 	target: CompositionTargetSchema,
-	features: z.array(CompositionFeatureSchema).min(1).max(16)
+	features: z.array(CompositionFeatureSchema).min(1).max(16),
+	/**
+	* Present when the block is a helper template. Absent on a free
+	* composition (the room example, device 4603). The editor reads this,
+	* never the compiled features.
+	*/
+	helper: HelperSpecSchema.optional()
 }).superRefine((composition, ctx) => {
 	const seen = /* @__PURE__ */ new Set();
 	composition.features.forEach((feature, index) => {
@@ -2358,6 +2470,7 @@ function fieldReads(source) {
 			cap: binding.cap,
 			fieldPath: binding.fieldPath
 		}] : []);
+		case "aggregate": return source.reads;
 		case "code": return [];
 	}
 }
@@ -2384,4 +2497,4 @@ function featureSources(feature) {
 	return featureFieldEntries(feature).map((e) => e.source);
 }
 //#endregion
-export { MAX_EXPRESSION_AST_NODES as $, compositionFeatureEnabled as A, Fmp4BoxSplitter as At, createStatefulExpressionMemory as B, pickVideoEncoder as Bt, CompositionTargetSchema as C, FFMPEG_PATH_ENV as Ct, MAX_COMPOSITION_ITEMS as D, getFfmpegArtifact as Dt, MAX_COMPOSITION_FIELDS_PER_FEATURE as E, FFMPEG_RELEASE as Et, featureFieldEntries as F, buildInputArgs as Ft, createExpressionScope as G, evaluateStatefulExpressionCall as H, featureSources as I, buildVideoArgs as It, compileExpressionSafe as J, evaluateAst as K, fieldReads as L, invocationFromEncodeProfile as Lt, compositionReadKey as M, audioPlanFromEncodeProfile as Mt, compositionSliceKey as N, buildAudioArgs as Nt, composedDeviceRef as O, getFfmpegDownloadUrl as Ot, compositionSourceKey as P, buildFfmpegArgs as Pt, EXPRESSION_IDENTIFIER_RE as Q, EXPRESSION_INJECTED_NOW as R, isSoftwareDecode as Rt, CompositionSourceRefSchema as S, sliceChangedAt as St, MAX_COMPOSITION_FEATURES as T, ffmpegBinaryName as Tt, toExpressionValue as U, evaluateExpressionSource as V, resolveStreamMaps as Vt, validateExpressionSource as W, tokenize as X, parseExpression as Y, EXPRESSION_COMPILE_CACHE_CAPACITY as Z, CompositionItemEntrySchema as _, SOURCE_DEVICE_TYPES as _t, CUSTOMIZATION_BLOCK_NAME_PREFIX as a, EXPRESSION_BUILTINS as at, CompositionPassthroughFeatureSchema as b, isSourceCap as bt, CompositionCommandTargetSchema as c, evaluateCount as ct, CompositionFeatureSchema as d, ExpressionEvalError as dt, MAX_EXPRESSION_BINDINGS as et, CompositionFieldReadSchema as f, ExpressionParseError as ft, CompositionFromSourceSchema as g, SOURCE_CAP_CHANGED_AT_FIELD as gt, CompositionForwardCommandSchema as h, SOURCE_CAP_ACTIVE_FIELD as ht, COMPOSITION_ITEM_KEY_RE as i, RESERVED_BINDING_NAMES as it, compositionItemFieldPath as j, AUDIO_PRESETS as jt, composedDeviceStableId as k, canonicalHash as kt, CompositionExistingTargetSchema as l, evaluateRose as lt, CompositionFieldsFeatureSchema as m, SOURCE_CAPS as mt, COMPOSER_ADDON_ID as n, MAX_EXPRESSION_EVAL_STEPS as nt, CompositionBindingSchema as o, EXPRESSION_BUILTIN_NAMES as ot, CompositionFieldSourceSchema as p, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as pt, compileExpression as q, COMPOSITION_ITEM_ARRAY_PATH as r, MAX_EXPRESSION_SOURCE_LENGTH as rt, CompositionCodeSourceSchema as s, disarmRoseMemory as st, COMPOSED_DEVICE_STABLE_ID_PREFIX as t, MAX_EXPRESSION_CALL_ARGS as tt, CompositionExpressionSourceSchema as u, isStatefulBuiltin as ut, CompositionLiteralBindingSchema as v, evaluateSensorEdge as vt, MAX_COMPOSITION_CODE_LENGTH as w, chooseFfmpegBinary as wt, CompositionSchema as x, sliceActiveValue as xt, CompositionNewTargetSchema as y, evaluateSensorLevelEdge as yt, cloneStatefulExpressionMemory as z, logBannerArgs as zt };
+export { createStatefulExpressionMemory as $, pickVideoEncoder as $t, compositionFeatureEnabled as A, SOURCE_DEVICE_TYPES as At, ActiveCriterionSchema as B, getFfmpegArtifact as Bt, CompositionTargetSchema as C, isStatefulBuiltin as Ct, MAX_COMPOSITION_ITEMS as D, SOURCE_CAPS as Dt, MAX_COMPOSITION_FIELDS_PER_FEATURE as E, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as Et, featureFieldEntries as F, sliceChangedAt as Ft, GroupTemplateIdSchema as G, audioPlanFromEncodeProfile as Gt, BINARY_AGGREGATES as H, canonicalHash as Ht, featureSources as I, FFMPEG_PATH_ENV as It, MAX_HELPER_MEMBERS as J, buildInputArgs as Jt, HelperMemberSchema as K, buildAudioArgs as Kt, fieldReads as L, chooseFfmpegBinary as Lt, compositionReadKey as M, evaluateSensorLevelEdge as Mt, compositionSliceKey as N, isSourceCap as Nt, composedDeviceRef as O, SOURCE_CAP_ACTIVE_FIELD as Ot, compositionSourceKey as P, sliceActiveValue as Pt, cloneStatefulExpressionMemory as Q, logBannerArgs as Qt, ACTIVE_CRITERIA as R, ffmpegBinaryName as Rt, CompositionSchema as S, evaluateRose as St, MAX_COMPOSITION_FEATURES as T, ExpressionParseError as Tt, GROUP_TEMPLATE_IDS as U, Fmp4BoxSplitter as Ut, AggregateReducerSchema as V, getFfmpegDownloadUrl as Vt, GroupHelperSpecSchema as W, AUDIO_PRESETS as Wt, CompositionSourceRefSchema as X, invocationFromEncodeProfile as Xt, NUMERIC_AGGREGATES as Y, buildVideoArgs as Yt, EXPRESSION_INJECTED_NOW as Z, isSoftwareDecode as Zt, CompositionFromSourceSchema as _, RESERVED_BINDING_NAMES as _t, CUSTOMIZATION_BLOCK_NAME_PREFIX as a, evaluateAst as at, CompositionNewTargetSchema as b, disarmRoseMemory as bt, CompositionCodeSourceSchema as c, parseExpression as ct, CompositionExpressionSourceSchema as d, EXPRESSION_IDENTIFIER_RE as dt, resolveStreamMaps as en, evaluateExpressionSource as et, CompositionFeatureSchema as f, MAX_EXPRESSION_AST_NODES as ft, CompositionForwardCommandSchema as g, MAX_EXPRESSION_SOURCE_LENGTH as gt, CompositionFieldsFeatureSchema as h, MAX_EXPRESSION_EVAL_STEPS as ht, COMPOSITION_ITEM_KEY_RE as i, createExpressionScope as it, compositionItemFieldPath as j, evaluateSensorEdge as jt, composedDeviceStableId as k, SOURCE_CAP_CHANGED_AT_FIELD as kt, CompositionCommandTargetSchema as l, tokenize as lt, CompositionFieldSourceSchema as m, MAX_EXPRESSION_CALL_ARGS as mt, COMPOSER_ADDON_ID as n, toExpressionValue as nt, CompositionAggregateSourceSchema as o, compileExpression as ot, CompositionFieldReadSchema as p, MAX_EXPRESSION_BINDINGS as pt, HelperSpecSchema as q, buildFfmpegArgs as qt, COMPOSITION_ITEM_ARRAY_PATH as r, validateExpressionSource as rt, CompositionBindingSchema as s, compileExpressionSafe as st, COMPOSED_DEVICE_STABLE_ID_PREFIX as t, evaluateStatefulExpressionCall as tt, CompositionExistingTargetSchema as u, EXPRESSION_COMPILE_CACHE_CAPACITY as ut, CompositionItemEntrySchema as v, EXPRESSION_BUILTINS as vt, MAX_COMPOSITION_CODE_LENGTH as w, ExpressionEvalError as wt, CompositionPassthroughFeatureSchema as x, evaluateCount as xt, CompositionLiteralBindingSchema as y, EXPRESSION_BUILTIN_NAMES as yt, AGGREGATE_REDUCERS as z, FFMPEG_RELEASE as zt };