@camstack/types 1.2.264 → 1.2.265

package/dist/capabilities/osd-manager.cap.d.ts

@@ -207,10 +207,10 @@ export declare const OsdSlotBindingSchema: z.ZodObject<{
             zoneId: z.ZodOptional<z.ZodString>;
             className: z.ZodOptional<z.ZodString>;
             op: z.ZodDefault<z.ZodEnum<{
+                "<=": "<=";
+                ">=": ">=";
                 "became-occupied": "became-occupied";
                 "became-free": "became-free";
-                ">=": ">=";
-                "<=": "<=";
             }>>;
             count: z.ZodDefault<z.ZodNumber>;
             sustainSeconds: z.ZodDefault<z.ZodNumber>;
@@ -392,10 +392,10 @@ export declare const OsdSlotViewSchema: z.ZodObject<{
                 zoneId: z.ZodOptional<z.ZodString>;
                 className: z.ZodOptional<z.ZodString>;
                 op: z.ZodDefault<z.ZodEnum<{
+                    "<=": "<=";
+                    ">=": ">=";
                     "became-occupied": "became-occupied";
                     "became-free": "became-free";
-                    ">=": ">=";
-                    "<=": "<=";
                 }>>;
                 count: z.ZodDefault<z.ZodNumber>;
                 sustainSeconds: z.ZodDefault<z.ZodNumber>;
@@ -649,10 +649,10 @@ export declare const osdManagerCapability: {
                             zoneId: z.ZodOptional<z.ZodString>;
                             className: z.ZodOptional<z.ZodString>;
                             op: z.ZodDefault<z.ZodEnum<{
+                                "<=": "<=";
+                                ">=": ">=";
                                 "became-occupied": "became-occupied";
                                 "became-free": "became-free";
-                                ">=": ">=";
-                                "<=": "<=";
                             }>>;
                             count: z.ZodDefault<z.ZodNumber>;
                             sustainSeconds: z.ZodDefault<z.ZodNumber>;
@@ -740,10 +740,10 @@ export declare const osdManagerCapability: {
                 }>;
                 operator: z.ZodEnum<{
                     in: "in";
+                    gte: "gte";
                     notIn: "notIn";
                     anyOf: "anyOf";
                     allOf: "allOf";
-                    gte: "gte";
                     fuzzyIn: "fuzzyIn";
                     withinSchedule: "withinSchedule";
                 }>;
@@ -925,10 +925,10 @@ export declare const osdManagerCapability: {
                         zoneId: z.ZodOptional<z.ZodString>;
                         className: z.ZodOptional<z.ZodString>;
                         op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
                             "became-occupied": "became-occupied";
                             "became-free": "became-free";
-                            ">=": ">=";
-                            "<=": "<=";
                         }>>;
                         count: z.ZodDefault<z.ZodNumber>;
                         sustainSeconds: z.ZodDefault<z.ZodNumber>;
@@ -1109,10 +1109,10 @@ export declare const osdManagerCapability: {
                             zoneId: z.ZodOptional<z.ZodString>;
                             className: z.ZodOptional<z.ZodString>;
                             op: z.ZodDefault<z.ZodEnum<{
+                                "<=": "<=";
+                                ">=": ">=";
                                 "became-occupied": "became-occupied";
                                 "became-free": "became-free";
-                                ">=": ">=";
-                                "<=": "<=";
                             }>>;
                             count: z.ZodDefault<z.ZodNumber>;
                             sustainSeconds: z.ZodDefault<z.ZodNumber>;
@@ -1325,10 +1325,10 @@ export declare const osdManagerCapability: {
                         zoneId: z.ZodOptional<z.ZodString>;
                         className: z.ZodOptional<z.ZodString>;
                         op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
                             "became-occupied": "became-occupied";
                             "became-free": "became-free";
-                            ">=": ">=";
-                            "<=": "<=";
                         }>>;
                         count: z.ZodDefault<z.ZodNumber>;
                         sustainSeconds: z.ZodDefault<z.ZodNumber>;

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

@@ -0,0 +1,36 @@
+/**
+ * The field graph across every composition, and the cycles in it (D659).
+ *
+ * A node is ONE field of ONE device (`<addon>/<stableId>#<cap>.<field>`); an
+ * edge points from a composed field to each field it reads. A cycle, direct or
+ * through another composition, is refused at save by name (spec §2).
+ *
+ * The graph is built for ONE save: the CANDIDATE composition (the one being
+ * validated) plus every STORED composition. The candidate ALWAYS replaces any
+ * stored peer that targets the same device, regardless of where that stored
+ * peer sits in `stored` — whether a save introduces or removes a cycle must
+ * never depend on array order. Two DIFFERENT stored peers that (wrongly)
+ * target the same device are corrupted state, not a cycle to resolve by
+ * picking one silently; that is refused by name (D391).
+ *
+ * `findCompositionCycles` reports at least one cycle per cycle-SET (the DFS
+ * marks a node `done` after its first expansion) — enough to refuse a save,
+ * not to enumerate every elementary cycle through a shared node. A dotted
+ * `fieldPath` is matched only as an exact string: a write to `state.value` and
+ * a read of `state` would not connect (no nested field writes exist yet).
+ */
+import { type Composition, type CompositionSourceRef } from './composition.js';
+export interface CompositionPeer {
+    /** The device this composition writes: `composedDeviceRef(blockId)` for a new target. */
+    readonly target: CompositionSourceRef;
+    readonly composition: Composition;
+}
+export interface CompositionCycle {
+    /** Node keys, first and last equal. */
+    readonly path: readonly string[];
+}
+/** Two stored compositions both target the same device — refused by name, never silently resolved. */
+export declare class CompositionGraphError extends Error {
+}
+export declare function compositionEdges(candidate: CompositionPeer, stored: readonly CompositionPeer[]): ReadonlyMap<string, readonly string[]>;
+export declare function findCompositionCycles(candidate: CompositionPeer, stored: readonly CompositionPeer[]): readonly CompositionCycle[];

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

@@ -0,0 +1,264 @@
+/**
+ * What the validator says about a composition and what the composer says about
+ * a running one: the wire shapes the API returns (D659).
+ */
+import { z } from 'zod';
+export declare const CompositionProblemCodeSchema: z.ZodEnum<{
+    "source-missing": "source-missing";
+    "reserved-variant": "reserved-variant";
+    "unknown-capability": "unknown-capability";
+    "not-composable": "not-composable";
+    "wrong-device-type": "wrong-device-type";
+    "has-commands": "has-commands";
+    "unknown-field": "unknown-field";
+    "nested-field": "nested-field";
+    "missing-field": "missing-field";
+    "kind-mismatch": "kind-mismatch";
+    "may-be-null": "may-be-null";
+    "source-unreadable": "source-unreadable";
+    "source-capability-missing": "source-capability-missing";
+    "source-field-unknown": "source-field-unknown";
+    "expression-invalid": "expression-invalid";
+    cycle: "cycle";
+    "duplicate-target": "duplicate-target";
+}>;
+export type CompositionProblemCode = z.infer<typeof CompositionProblemCodeSchema>;
+/** One refusal, named (D391). `path` points into the composition, e.g. `features[0].fields.celsius`. */
+export declare const CompositionProblemSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        "source-missing": "source-missing";
+        "reserved-variant": "reserved-variant";
+        "unknown-capability": "unknown-capability";
+        "not-composable": "not-composable";
+        "wrong-device-type": "wrong-device-type";
+        "has-commands": "has-commands";
+        "unknown-field": "unknown-field";
+        "nested-field": "nested-field";
+        "missing-field": "missing-field";
+        "kind-mismatch": "kind-mismatch";
+        "may-be-null": "may-be-null";
+        "source-unreadable": "source-unreadable";
+        "source-capability-missing": "source-capability-missing";
+        "source-field-unknown": "source-field-unknown";
+        "expression-invalid": "expression-invalid";
+        cycle: "cycle";
+        "duplicate-target": "duplicate-target";
+    }>;
+    path: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type CompositionProblem = z.infer<typeof CompositionProblemSchema>;
+export declare const CompositionFieldKindSchema: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    enum: "enum";
+}>;
+export type CompositionFieldKind = z.infer<typeof CompositionFieldKindSchema>;
+/** How a field says "unavailable": `null` when its schema allows it, else the device goes offline (D393). */
+export declare const CompositionUnavailableModeSchema: z.ZodEnum<{
+    null: "null";
+    offline: "offline";
+}>;
+export type CompositionUnavailableMode = z.infer<typeof CompositionUnavailableModeSchema>;
+/**
+ * `derived` reads a source · `clock` reads only `now`, recomputed when a sibling
+ * field of its cap changes value · `constant` reads nothing, computed once.
+ */
+export declare const CompositionFieldRoleSchema: z.ZodEnum<{
+    derived: "derived";
+    clock: "clock";
+    constant: "constant";
+}>;
+export type CompositionFieldRole = z.infer<typeof CompositionFieldRoleSchema>;
+export declare const CompositionFieldPlanSchema: z.ZodObject<{
+    cap: z.ZodString;
+    path: z.ZodString;
+    featureIndex: z.ZodNumber;
+    kind: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        enum: "enum";
+    }>;
+    nullable: z.ZodBoolean;
+    required: z.ZodBoolean;
+    unavailable: z.ZodEnum<{
+        null: "null";
+        offline: "offline";
+    }>;
+    role: z.ZodEnum<{
+        derived: "derived";
+        clock: "clock";
+        constant: "constant";
+    }>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodObject<{
+            addonId: z.ZodString;
+            stableId: z.ZodString;
+        }, z.core.$strip>;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+        kind: z.ZodLiteral<"from">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"expression">;
+        expr: z.ZodString;
+        bindings: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodObject<{
+                addonId: z.ZodString;
+                stableId: z.ZodString;
+            }, z.core.$strip>;
+            cap: z.ZodString;
+            fieldPath: z.ZodString;
+            kind: z.ZodLiteral<"from">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"literal">;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"code">;
+        code: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    reads: z.ZodArray<z.ZodObject<{
+        source: z.ZodObject<{
+            addonId: z.ZodString;
+            stableId: z.ZodString;
+        }, z.core.$strip>;
+        cap: z.ZodString;
+        fieldPath: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CompositionFieldPlan = z.infer<typeof CompositionFieldPlanSchema>;
+export declare const CompositionValidationSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    problems: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            "source-missing": "source-missing";
+            "reserved-variant": "reserved-variant";
+            "unknown-capability": "unknown-capability";
+            "not-composable": "not-composable";
+            "wrong-device-type": "wrong-device-type";
+            "has-commands": "has-commands";
+            "unknown-field": "unknown-field";
+            "nested-field": "nested-field";
+            "missing-field": "missing-field";
+            "kind-mismatch": "kind-mismatch";
+            "may-be-null": "may-be-null";
+            "source-unreadable": "source-unreadable";
+            "source-capability-missing": "source-capability-missing";
+            "source-field-unknown": "source-field-unknown";
+            "expression-invalid": "expression-invalid";
+            cycle: "cycle";
+            "duplicate-target": "duplicate-target";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    fields: z.ZodArray<z.ZodObject<{
+        cap: z.ZodString;
+        path: z.ZodString;
+        featureIndex: z.ZodNumber;
+        kind: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            enum: "enum";
+        }>;
+        nullable: z.ZodBoolean;
+        required: z.ZodBoolean;
+        unavailable: z.ZodEnum<{
+            null: "null";
+            offline: "offline";
+        }>;
+        role: z.ZodEnum<{
+            derived: "derived";
+            clock: "clock";
+            constant: "constant";
+        }>;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodObject<{
+                addonId: z.ZodString;
+                stableId: z.ZodString;
+            }, z.core.$strip>;
+            cap: z.ZodString;
+            fieldPath: z.ZodString;
+            kind: z.ZodLiteral<"from">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"expression">;
+            expr: z.ZodString;
+            bindings: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                source: z.ZodObject<{
+                    addonId: z.ZodString;
+                    stableId: z.ZodString;
+                }, z.core.$strip>;
+                cap: z.ZodString;
+                fieldPath: z.ZodString;
+                kind: z.ZodLiteral<"from">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"literal">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$strip>], "kind">>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"code">;
+            code: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        reads: z.ZodArray<z.ZodObject<{
+            source: z.ZodObject<{
+                addonId: z.ZodString;
+                stableId: z.ZodString;
+            }, z.core.$strip>;
+            cap: z.ZodString;
+            fieldPath: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CompositionValidation = z.infer<typeof CompositionValidationSchema>;
+/** Mirrors `CoreBlockStatus`, pinned by `core-blocks-source.spec.ts` (Task 11). */
+export declare const CompositionRunStatusSchema: z.ZodEnum<{
+    running: "running";
+    failed: "failed";
+    stopped: "stopped";
+    starting: "starting";
+}>;
+export type CompositionRunStatus = z.infer<typeof CompositionRunStatusSchema>;
+export declare const CompositionFieldStateKindSchema: z.ZodEnum<{
+    unavailable: "unavailable";
+    fresh: "fresh";
+    stale: "stale";
+}>;
+export type CompositionFieldStateKind = z.infer<typeof CompositionFieldStateKindSchema>;
+export declare const CompositionFieldStateSchema: z.ZodObject<{
+    cap: z.ZodString;
+    path: z.ZodString;
+    state: z.ZodEnum<{
+        unavailable: "unavailable";
+        fresh: "fresh";
+        stale: "stale";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CompositionFieldState = z.infer<typeof CompositionFieldStateSchema>;
+export declare const CompositionBlockStateSchema: z.ZodObject<{
+    blockId: z.ZodString;
+    deviceId: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        stopped: "stopped";
+        starting: "starting";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        cap: z.ZodString;
+        path: z.ZodString;
+        state: z.ZodEnum<{
+            unavailable: "unavailable";
+            fresh: "fresh";
+            stale: "stale";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CompositionBlockState = z.infer<typeof CompositionBlockStateSchema>;