@camstack/types 1.2.402 → 1.2.404

package/dist/interfaces/api-responses.d.ts

@@ -48,7 +48,7 @@ export interface SafeUser {
      * for non-admins until an admin assigns scopes via `setUserScopes`.
      * Wire-side default `[]` from the Zod schema.
      */
-    readonly scopes: readonly import('../schemas/auth-records.js').TokenScope[];
+    readonly scopes: readonly import('../schemas/auth-records.js').UserScope[];
     /**
      * True iff a confirmed TOTP enrollment exists for this user — surfaced
      * by `listUsers` so the admin UI can render the "Remove 2FA" action

package/dist/interfaces/auth.d.ts

@@ -1,5 +1,5 @@
 export { type UserRecord, type TokenScope } from '../schemas/auth-records.js';
-import type { TokenScope } from '../schemas/auth-records.js';
+import type { UserScope } from '../schemas/auth-records.js';
 export interface UserPermissions {
     isAdmin: boolean;
     allowedProviders: string[] | '*';
@@ -34,7 +34,7 @@ export interface TokenPayload {
      * user's NEXT login — existing JWTs carry the snapshot from
      * issue-time. Re-issue on the client by logging out and back in.
      */
-    scopes?: readonly TokenScope[];
+    scopes?: readonly UserScope[];
     iat?: number;
     exp?: number;
 }

package/dist/interfaces/birth-decision-ledger.d.ts

@@ -84,6 +84,18 @@ export declare const BirthDecisionVerdictSchema: z.ZodEnum<{
     suppressed: "suppressed";
 }>;
 export type BirthDecisionVerdict = z.infer<typeof BirthDecisionVerdictSchema>;
+/**
+ * Which pixels a gate verdict was taken on (D379): `native` is a full-resolution
+ * crop of the birth's own frame and the ONLY source that may suppress;
+ * `carried` is that instant at analysis resolution and `fallback` a later
+ * instant — both may only confirm.
+ */
+export declare const BirthDecisionCropSourceSchema: z.ZodEnum<{
+    carried: "carried";
+    fallback: "fallback";
+    native: "native";
+}>;
+export type BirthDecisionCropSource = z.infer<typeof BirthDecisionCropSourceSchema>;
 /** One birth decision, as it is kept. */
 export declare const BirthDecisionRecordSchema: z.ZodObject<{
     id: z.ZodString;
@@ -97,6 +109,11 @@ export declare const BirthDecisionRecordSchema: z.ZodObject<{
         suppressed: "suppressed";
     }>;
     reason: z.ZodNullable<z.ZodString>;
+    cropSource: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+        carried: "carried";
+        fallback: "fallback";
+        native: "native";
+    }>>>;
     attempts: z.ZodNumber;
     deferredForMs: z.ZodNumber;
     decidedOnCoastedFrame: z.ZodBoolean;
@@ -104,6 +121,9 @@ export declare const BirthDecisionRecordSchema: z.ZodObject<{
     decidedByBirthEvidence: z.ZodBoolean;
     bestScore: z.ZodNullable<z.ZodNumber>;
     appliedMinConfidence: z.ZodNullable<z.ZodNumber>;
+    detectorModelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    detectorDeviceKey: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    detectorNodeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     firstSeen: z.ZodNullable<z.ZodNumber>;
     motionOnsetAt: z.ZodNullable<z.ZodNumber>;
     birthLatencyMs: z.ZodNullable<z.ZodNumber>;

package/dist/interfaces/pipeline-executor-capability.d.ts

@@ -1,6 +1,6 @@
-import type { PipelineEngineChoice, PipelineConfig } from '../types/pipeline.js';
+import type { PipelineEngineChoice } from '../types/pipeline.js';
 import type { PipelineExecutionPlane } from '../types/pipeline-step.js';
-import type { PipelineSchema, PipelineDefaultStep } from '../types/pipeline-schema.js';
+import type { PipelineSchema } from '../types/pipeline-schema.js';
 import type { ModelFormat } from '../types/models.js';
 import type { FrameInput } from '../types/io.js';
 import type { FrameRef } from '../types/frame-view.js';
@@ -112,12 +112,6 @@ export interface IPipelineExecutorProvider {
     getSchema(engine?: PipelineEngineChoice): Promise<PipelineSchema>;
     /** Get all available engines probed on this agent */
     getAvailableEngines(): Promise<PipelineEngineChoice[]>;
-    /** Build default step tree for an engine */
-    getDefaultSteps(engine: PipelineEngineChoice): Promise<PipelineDefaultStep[]>;
-    /** Compute this node's hardware-aware default step tree (null when the catalog yields no steps). */
-    getGlobalSteps(): Promise<PipelineDefaultStep[] | null>;
-    /** Get the runner-ready pipeline config */
-    getGlobalPipelineConfig(): Promise<PipelineConfig | null>;
     /**
      * Gate B (pre-init config-correctness gate). PURE COMPUTE against this
      * node's `currentEngine.format` — resolves `steps` the same way the

package/dist/pipeline/auto-tune/plan-schemas.d.ts

@@ -381,33 +381,15 @@ export declare const NodeDeviceChangeSchema: z.ZodObject<{
         keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
-export declare const CameraOverrideClearSchema: z.ZodObject<{
-    deviceId: z.ZodNumber;
-    source: z.ZodEnum<{
-        "step-override": "step-override";
-        wholesale: "wholesale";
-    }>;
-    nodeId: z.ZodString;
-    deviceKey: z.ZodNullable<z.ZodString>;
-    stepId: z.ZodString;
-    modelIdBefore: z.ZodNullable<z.ZodString>;
-    keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const DetectorStoreClearSchema: z.ZodObject<{
-    deviceId: z.ZodNumber;
-    keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+/**
+ * Every model and model-bound threshold lives on the accelerator that runs it
+ * (D927), so the plan writes node / device entries only — there is no camera
+ * layer for it to clear.
+ */
 export declare const AutoTuneWarningSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"detector-store-cluster-wide">;
-    skippedNodes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"detector-store-unreadable">;
-    error: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"custom-pin-kept">;
     nodeId: z.ZodString;
-    deviceKey: z.ZodNullable<z.ZodString>;
-    deviceId: z.ZodNullable<z.ZodNumber>;
+    deviceKey: z.ZodString;
     modelId: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"custom-registry-unreadable">;
@@ -596,33 +578,10 @@ export declare const AutoTunePlanSchema: z.ZodObject<{
             keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>>;
-    cameraClears: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        deviceId: z.ZodNumber;
-        source: z.ZodEnum<{
-            "step-override": "step-override";
-            wholesale: "wholesale";
-        }>;
-        nodeId: z.ZodString;
-        deviceKey: z.ZodNullable<z.ZodString>;
-        stepId: z.ZodString;
-        modelIdBefore: z.ZodNullable<z.ZodString>;
-        keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
-    detectorStoreClears: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-        deviceId: z.ZodNumber;
-        keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>;
     warnings: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"detector-store-cluster-wide">;
-        skippedNodes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
-        kind: z.ZodLiteral<"detector-store-unreadable">;
-        error: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"custom-pin-kept">;
         nodeId: z.ZodString;
-        deviceKey: z.ZodNullable<z.ZodString>;
-        deviceId: z.ZodNullable<z.ZodNumber>;
+        deviceKey: z.ZodString;
         modelId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"custom-registry-unreadable">;
@@ -636,8 +595,6 @@ export declare const AutoTuneApplyInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const AutoTunePhaseResultSchema: z.ZodObject<{
     phase: z.ZodEnum<{
-        "camera-overrides": "camera-overrides";
-        "detector-thresholds": "detector-thresholds";
         download: "download";
         "node-models": "node-models";
         redispatch: "redispatch";
@@ -650,8 +607,6 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     planHash: z.ZodString;
     phases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         phase: z.ZodEnum<{
-            "camera-overrides": "camera-overrides";
-            "detector-thresholds": "detector-thresholds";
             download: "download";
             "node-models": "node-models";
             redispatch: "redispatch";
@@ -663,8 +618,6 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     kind: z.ZodLiteral<"aborted">;
     phases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
         phase: z.ZodEnum<{
-            "camera-overrides": "camera-overrides";
-            "detector-thresholds": "detector-thresholds";
             download: "download";
             "node-models": "node-models";
             redispatch: "redispatch";
@@ -853,33 +806,10 @@ export declare const AutoTuneApplyResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
                 keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>>>;
-        cameraClears: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            source: z.ZodEnum<{
-                "step-override": "step-override";
-                wholesale: "wholesale";
-            }>;
-            nodeId: z.ZodString;
-            deviceKey: z.ZodNullable<z.ZodString>;
-            stepId: z.ZodString;
-            modelIdBefore: z.ZodNullable<z.ZodString>;
-            keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>;
-        detectorStoreClears: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            deviceId: z.ZodNumber;
-            keys: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>;
         warnings: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"detector-store-cluster-wide">;
-            skippedNodes: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"detector-store-unreadable">;
-            error: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"custom-pin-kept">;
             nodeId: z.ZodString;
-            deviceKey: z.ZodNullable<z.ZodString>;
-            deviceId: z.ZodNullable<z.ZodNumber>;
+            deviceKey: z.ZodString;
             modelId: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"custom-registry-unreadable">;
@@ -898,8 +828,6 @@ export type AutoTuneApplyInput = z.infer<typeof AutoTuneApplyInputSchema>;
 export type AutoTuneApplyResult = z.infer<typeof AutoTuneApplyResultSchema>;
 export type AutoTunePhaseResult = z.infer<typeof AutoTunePhaseResultSchema>;
 export type AutoTuneWarning = z.infer<typeof AutoTuneWarningSchema>;
-export type DetectorStoreClear = z.infer<typeof DetectorStoreClearSchema>;
-export type AutoTuneCameraOverrideClear = z.infer<typeof CameraOverrideClearSchema>;
 export type AutoTuneNodeDeviceChange = z.infer<typeof NodeDeviceChangeSchema>;
 export type HardwareClassId = z.infer<typeof HardwareClassIdSchema>;
 export type AcceleratorKind = z.infer<typeof AcceleratorKindSchema>;

package/dist/pipeline/step-settings-layers.d.ts

@@ -1,13 +1,13 @@
 /**
  * The layers of a detection step's settings, and the field-level edits on them
- * (D754).
+ * (D754, D927).
  *
- * A step's settings reach a session through up to three stored layers, merged
- * key by key — a key in a higher layer wins:
+ * A step's settings reach a session through two stored layers, merged key by
+ * key — a key in the higher layer wins:
  *
- *   node         the node's folded base (`inferenceDevices[node][*].steps`)
- *   camera       `cameraSettings[cam].stepSettings[step]` — every accelerator
- *   accelerator  `cameraSettings[cam].stepOverridesByDevice[node][key][step].settings`
+ *   node         the node's base for the accelerator that runs the step
+ *   camera       `cameraSettings[cam].stepSettings[step]` — camera-semantic
+ *                keys only, on every accelerator (never a model-bound field)
  *
  * Below them sits the default: the running model's (D738) or the field's own.
  *
@@ -27,12 +27,11 @@
 export type StepSettingsBag = Readonly<Record<string, unknown>>;
 /** The stored layers, from the top. `undefined` = the layer stores nothing for this step. */
 export interface StepSettingsLayers {
-    readonly accelerator?: StepSettingsBag;
     readonly camera?: StepSettingsBag;
     readonly node?: StepSettingsBag;
 }
 /** Which stored layer supplies a field, or `default` when none does. */
-export type StepSettingSource = 'accelerator' | 'camera' | 'node' | 'default';
+export type StepSettingSource = 'camera' | 'node' | 'default';
 /**
  * The keys one field occupies in a bag: its own, plus its binding key when it
  * binds to a model. `boundKeys` = `collectModelBoundKeys(schema)`.

package/dist/schemas/auth-records.d.ts

@@ -1,14 +1,3 @@
-/**
- * Zod schemas for persisted record types.
- *
- * These schemas serve as the single source of truth for types that are
- * stored in the settings-store backend and retrieved via tRPC. They
- * replace the manual TypeScript interfaces with schema-derived types,
- * enabling runtime validation when reading from the backend.
- *
- * Convention: each schema is named `<Type>Schema`, the inferred TS type
- * keeps the original name for backward compatibility.
- */
 import { z } from 'zod';
 import { DeviceType } from '../device/device-type.js';
 /**
@@ -141,6 +130,71 @@ export declare const TokenScopeSchema: z.ZodPreprocess<z.ZodDiscriminatedUnion<[
     includeLinked: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>], "type">>;
 export type TokenScope = z.infer<typeof TokenScopeSchema>;
+/**
+ * What a PERSON's grant set holds (D921): the capability rows above (legacy
+ * users, integration-style tokens) or the viewer row, which is decided by its
+ * own rules alone. Kept apart from {@link TokenScope} so every surface that
+ * edits capability rows (the scope picker, token minting) keeps its shape.
+ */
+export declare const UserScopeSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"viewer">;
+    allow: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodNumber>]>;
+    block: z.ZodArray<z.ZodNumber>;
+    features: z.ZodArray<z.ZodEnum<{
+        "face-assignment": "face-assignment";
+        "plate-assignment": "plate-assignment";
+        retrain: "retrain";
+        scenes: "scenes";
+    }>>;
+}, z.core.$strip>, z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"category">;
+    target: z.ZodEnum<{
+        device: "device";
+        system: "system";
+    }>;
+    access: z.ZodArray<z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        view: "view";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"capability">;
+    target: z.ZodString;
+    access: z.ZodArray<z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        view: "view";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"addon">;
+    target: z.ZodString;
+    access: z.ZodArray<z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        view: "view";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"device">;
+    selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"all">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"ids">;
+        ids: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"types">;
+        types: z.ZodArray<z.ZodEnum<typeof DeviceType>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"locations">;
+        locations: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>], "kind">;
+    access: z.ZodArray<z.ZodEnum<{
+        create: "create";
+        delete: "delete";
+        view: "view";
+    }>>;
+    includeLinked: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "type">>]>;
+export type UserScope = z.infer<typeof UserScopeSchema>;
 /** The `device`-typed member of {@link TokenScope}, narrowed for matchers. */
 export type DeviceTokenScope = z.infer<typeof DeviceTokenScopeSchema>;
 export declare const UserRecordSchema: z.ZodObject<{
@@ -150,7 +204,17 @@ export declare const UserRecordSchema: z.ZodObject<{
     isAdmin: z.ZodDefault<z.ZodBoolean>;
     allowedProviders: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>;
     allowedDevices: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>;
-    scopes: z.ZodDefault<z.ZodArray<z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    scopes: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"viewer">;
+        allow: z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodNumber>]>;
+        block: z.ZodArray<z.ZodNumber>;
+        features: z.ZodArray<z.ZodEnum<{
+            "face-assignment": "face-assignment";
+            "plate-assignment": "plate-assignment";
+            retrain: "retrain";
+            scenes: "scenes";
+        }>>;
+    }, z.core.$strip>, z.ZodPreprocess<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"category">;
         target: z.ZodEnum<{
             device: "device";
@@ -197,7 +261,7 @@ export declare const UserRecordSchema: z.ZodObject<{
             view: "view";
         }>>;
         includeLinked: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>], "type">>>>;
+    }, z.core.$strip>], "type">>]>>>;
     createdAt: z.ZodNumber;
     updatedAt: z.ZodNumber;
 }, z.core.$strip>;

package/dist/schemas/device-selector.d.ts

@@ -13,7 +13,14 @@
  *
  * No I/O, no registry — the fleet + parentage are passed in.
  */
-import type { DeviceSelector, DeviceTokenScope, MethodAccess, TokenScope } from './auth-records.js';
+import type { DeviceSelector, DeviceTokenScope, MethodAccess, TokenScope, UserScope } from './auth-records.js';
+import { type ViewerFeatureId, type ViewerTokenScope } from '../auth/viewer-access.js';
+/**
+ * The viewer grant that decides this principal, or `null`. A set holding one
+ * is decided by it ALONE (D921): the first viewer row wins, the rest of the
+ * set is ignored, so a leftover grant can never widen a viewer.
+ */
+export declare function viewerScopeOf(scopes: readonly UserScope[]): ViewerTokenScope | null;
 /** The minimal device shape selectors resolve against. */
 export interface DeviceMetaLike {
     readonly id: number;
@@ -39,7 +46,12 @@ export declare function scopeInherits(scope: DeviceTokenScope, access: MethodAcc
  * grant inherits) against an ancestor, so a parent grant covers its
  * accessories.
  */
-export declare function resolveViewableDeviceIds(scopes: readonly TokenScope[], fleet: readonly DeviceMetaLike[], access: MethodAccess): Set<number>;
+export declare function resolveViewableDeviceIds(scopes: readonly UserScope[], fleet: readonly DeviceMetaLike[], access: MethodAccess): Set<number>;
+/**
+ * The capability rows of a set — a viewer row (D921) dropped. For surfaces
+ * that edit or display capability rows and have no meaning for a viewer row.
+ */
+export declare function grantRowsOf(scopes: readonly UserScope[]): TokenScope[];
 /**
  * Normalise a raw scope array read off a JWT payload or a stored record into
  * validated v3 `TokenScope`s, migrating any v2 `device:targets` grant on the
@@ -51,7 +63,7 @@ export declare function resolveViewableDeviceIds(scopes: readonly TokenScope[],
  * a lockout, and a lockout reads as broken. A non-array input yields `[]`
  * (fail closed).
  */
-export declare function normalizeTokenScopes(raw: unknown): TokenScope[];
+export declare function normalizeTokenScopes(raw: unknown): UserScope[];
 /** A capability/addon grant flattened for the UI. */
 export interface ScopeGrantSummary {
     readonly name: string;
@@ -70,6 +82,13 @@ export interface DeviceReachSummary {
  */
 export interface EffectiveScope {
     readonly isAdmin: boolean;
+    /**
+     * `admin`, `viewer` (D921), or `scoped` — a legacy grant set decided by the
+     * pre-D921 matcher until the operator converts it.
+     */
+    readonly role: 'admin' | 'viewer' | 'scoped';
+    /** The features granted to a viewer; empty for every other role. */
+    readonly features: readonly ViewerFeatureId[];
     /** true iff every device is viewable (admin, `category:device[view]`, or a
      *  device grant with an `all` selector). */
     readonly allDevicesViewable: boolean;
@@ -85,4 +104,4 @@ export interface EffectiveScope {
     readonly addons: readonly ScopeGrantSummary[];
 }
 /** Build the {@link EffectiveScope} for a caller from their scopes + the fleet. */
-export declare function summarizeEffectiveScope(scopes: readonly TokenScope[], fleet: readonly DeviceMetaLike[], isAdmin: boolean): EffectiveScope;
+export declare function summarizeEffectiveScope(scopes: readonly UserScope[], fleet: readonly DeviceMetaLike[], isAdmin: boolean): EffectiveScope;

package/dist/{sleep-DVovpDRU.js → sleep-BKS4OPMo.js}

@@ -1,4 +1,4 @@
-const require_event_category = require("./event-category-7AwNbPjm.js");
+const require_event_category = require("./event-category-CXrwjC3e.js");
 let zod = require("zod");
 //#region src/audio/audio-chunk-format.ts
 /**
@@ -6175,6 +6175,7 @@ function method(input, output, options) {
 		kind: options?.kind ?? "query",
 		...options?.auth !== void 0 ? { auth: options.auth } : {},
 		...options?.access !== void 0 ? { access: options.access } : {},
+		...options?.role !== void 0 ? { role: options.role } : {},
 		...options?.caller !== void 0 ? { caller: options.caller } : {},
 		timeoutMs: options?.timeoutMs
 	};
@@ -7539,10 +7540,7 @@ function createDeviceProxy(api, binding, opts) {
 		setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
 		getCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "getCameraDetectionSource", "query", input),
 		setCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "setCameraDetectionSource", "mutation", input),
-		getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
-		setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
 		setCameraStepSettings: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepSettings", "mutation", input),
-		setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 		resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
 		getCameraSwitches: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSwitches", "query", input),
 		setCameraSwitch: (input) => dispatchSystem("pipelineOrchestrator", "setCameraSwitch", "mutation", input),

package/dist/{sleep-CUp20JkO.mjs → sleep-CHIEEJkY.mjs}

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-BfJwUd2S.mjs";
+import { t as EventCategory } from "./event-category-fDPduoeC.mjs";
 import { z } from "zod";
 //#region src/audio/audio-chunk-format.ts
 /**
@@ -6175,6 +6175,7 @@ function method(input, output, options) {
 		kind: options?.kind ?? "query",
 		...options?.auth !== void 0 ? { auth: options.auth } : {},
 		...options?.access !== void 0 ? { access: options.access } : {},
+		...options?.role !== void 0 ? { role: options.role } : {},
 		...options?.caller !== void 0 ? { caller: options.caller } : {},
 		timeoutMs: options?.timeoutMs
 	};
@@ -7539,10 +7540,7 @@ function createDeviceProxy(api, binding, opts) {
 		setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
 		getCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "getCameraDetectionSource", "query", input),
 		setCameraDetectionSource: (input) => dispatchSystem("pipelineOrchestrator", "setCameraDetectionSource", "mutation", input),
-		getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
-		setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
 		setCameraStepSettings: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepSettings", "mutation", input),
-		setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 		resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
 		getCameraSwitches: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSwitches", "query", input),
 		setCameraSwitch: (input) => dispatchSystem("pipelineOrchestrator", "setCameraSwitch", "mutation", input),

package/dist/types/agent-pipeline-settings.d.ts

@@ -9,39 +9,21 @@
  *   2. Camera opts in or out of specific addonIds via a boolean overlay
  *      (`stepToggles`). Absent = inherit agent. Present = force.
  *
- *   3. Escape hatch: camera can pin a full pipeline wholesale for a
- *      specific agent via `pipelineByAgent[agentNodeId]`. When set, it
- *      bypasses addonDefaults + stepToggles entirely.
+ *   3. A model is chosen by the accelerator that runs it (D927): a camera
+ *      turns steps on or off and may carry camera-semantic step settings,
+ *      never a model, a model-bound threshold or a tree of its own.
  *
  * The resolver walks this chain and emits the existing
  * `CameraPipelineConfig` shape that the runner consumes — no changes
  * required downstream of the orchestrator.
  */
-import type { CameraPipelineConfig } from './camera-pipeline.js';
 import type { NodeColorId } from '../node-color.js';
-/**
- * LEGACY per-addon configuration (the removed per-node model layer,
- * `agent.addonDefaults[addonId]`). Retained ONLY for the one-shot boot
- * migration that strips `addonDefaults`, and for UI/library code pending
- * the per-(node,device) rework. New code carries model/settings per
- * `(node,device)` via {@link DeviceStepConfig}.
- *
- * modelId present ONLY when the operator explicitly chose a model;
- * absent = use this node's format default (resolved on-the-fly by the
- * provider).
- */
-export interface AgentAddonConfig {
-    readonly enabled: boolean;
-    readonly modelId?: string;
-    readonly settings: Readonly<Record<string, unknown>>;
-}
 /**
  * Per-(node,device) BASE provisioning for one step: the model + intrinsic
  * settings the executing node applies for EVERY camera landing on that
  * accelerator. Both fields optional — absent = the executor resolves its own
- * format default at runtime. This is the same shape carried by the
- * per-camera-device OVERRIDE ({@link CameraStepOverridePatch}); the dispatch
- * provisioning stage merges override on top of base (`override ?? base`).
+ * format default at runtime. The ONE authority over which model a step runs
+ * on an accelerator (D927) — no camera layer overrides it.
  */
 export interface DeviceStepConfig {
     readonly modelId?: string;
@@ -55,17 +37,6 @@ export interface DeviceStepConfig {
      */
     readonly jumpDeviceKey?: string;
 }
-/**
- * Per-(camera,node,device,step) override patch over the per-(node,device)
- * base ({@link DeviceStepConfig}). Both fields optional — unset means
- * "inherit from the device base". Enablement is NOT carried here: which
- * steps run is the per-camera `stepToggles` authority. When `settings` is
- * present it merges over the base `settings` (override keys win).
- */
-export interface CameraStepOverridePatch {
-    readonly modelId?: string;
-    readonly settings?: Readonly<Record<string, unknown>>;
-}
 /**
  * Per-agent pipeline settings. Phase 2f: engine + hwaccel + audio
  * ownership moved to per-addon global settings (detection-pipeline,
@@ -128,6 +99,15 @@ export interface AgentPipelineSettings {
      * `assignNodeColorId(nodeId)` when missing.
      */
     readonly color?: NodeColorId;
+    /**
+     * NODE-wide step settings (D927): `[stepId] → { fieldKey → value }`, the
+     * content that holds on every accelerator of this node (an allow-list of
+     * species, an IoU). Never a model or a model-bound threshold — those belong
+     * to the accelerator (`inferenceDevices[key].steps[step]`). Merged under
+     * the device's own settings at dispatch; a sibling device entry is never
+     * read.
+     */
+    readonly stepSettings?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
     /**
      * Multi-device inference opt-in (Phase 4 multi-device). Maps a device key
      * (`openvino:npu`, `openvino:gpu`, `edgetpu:usb`, `edgetpu:usb:1`, `cpu`, …
@@ -142,8 +122,8 @@ export interface AgentPipelineSettings {
      *
      * `steps` (per-(node,device) BASE provisioning) — an optional
      * `stepId → {modelId?, settings?}` map: the default model + intrinsic
-     * settings for EVERY camera landing on that accelerator, overridable
-     * per-camera via `cameraSettings.stepOverridesByDevice`. A stepId ABSENT ⇒
+     * settings for EVERY camera landing on that accelerator (no camera layer
+     * overrides the model, D927). A stepId ABSENT ⇒
      * that step uses the device format default. A pinned modelId MUST have a
      * build for the device's FORMAT, else the executor's `resolveInputSteps`
      * substitutes it back to the format default (the UI only offers
@@ -166,40 +146,27 @@ export interface AgentPipelineSettings {
 export interface CameraPipelineSettings {
     readonly stepToggles?: Readonly<Record<string, boolean>>;
     /**
-     * Camera-wide step SETTINGS (D754): `[addonId] → { fieldKey → value }`, the
-     * fields this camera overrides on EVERY accelerator it is balanced onto. A
-     * sparse, field-level bag — a key present here is an override, an absent key
-     * inherits the node. Merge order at dispatch, per key:
-     * node (folded base) ⊕ this ⊕ `stepOverridesByDevice[node][deviceKey]`.
-     * A model-bound field (D738) is always written with its binding key.
-     * Settings only: a model is a per-accelerator question (formats differ), so
-     * it stays in `stepOverridesByDevice`.
+     * Camera-wide step SETTINGS (D754, narrowed by D927): `[addonId] → { fieldKey
+     * → value }`, the CAMERA-SEMANTIC fields this camera overrides on every
+     * accelerator it is balanced onto (an allow-list of classes, a zone-driven
+     * option). A sparse, field-level bag — a key present here is an override, an
+     * absent key inherits the node. Merge order at dispatch, per key:
+     * node ⊕ this. Never a model and never a model-bound threshold
+     * ({@link isModelScopedStepSettingKey}): those belong to the accelerator that
+     * runs the model — the writer refuses them and dispatch ignores a stored one.
      */
     readonly stepSettings?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-    /**
-     * Per-(camera,node,device) model/settings override. Addressed by
-     * `[agentNodeId][deviceKey][addonId]` because the camera is balanced onto
-     * one `(node,deviceKey)` per session and a node's accelerators share no
-     * format. Overrides the per-(node,device) base
-     * (`inferenceDevices[node][deviceKey].steps`) for one camera on one
-     * accelerator; the wholesale `pipelineByAgent[agent]` escape hatch, when
-     * present, still bypasses this. Enablement is orthogonal (`stepToggles`).
-     */
-    readonly stepOverridesByDevice?: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, CameraStepOverridePatch>>>>>>;
-    /**
-     * Per-agent wholesale pipeline override. Engine is NOT stored here —
-     * the override runs under the engine selected on that agent via the
-     * detection-pipeline addon's global settings. Operator picks steps
-     * + audio model/enabled only. This keeps the override portable
-     * across agent-moves and prevents a camera from being pinned to an
-     * engine the agent doesn't host. `modelId` absent = data-only model
-     * selection — the executing node resolves its own format default.
-     */
-    readonly pipelineByAgent?: Readonly<Record<string, {
-        readonly steps: CameraPipelineConfig['steps'];
-        readonly audio: {
-            readonly modelId?: string;
-            readonly enabled: boolean;
-        } | null;
-    }>>;
 }
+/**
+ * Is `key` a step setting that only the accelerator running the model may
+ * carry (D927)? A model id, a model binding (`<key>ModelId`, D738) or a
+ * confidence floor (`minConfidence*` — every `bindsToModel` field). A camera
+ * layer never stores one: the floor of one model is wrong on the next, and a
+ * camera does not know which accelerator — or which model — it lands on.
+ * (Per-camera thresholds are a possible future extension, see D927.)
+ */
+export declare function isModelScopedStepSettingKey(key: string): boolean;
+/** The keys of `bag` a camera layer may not carry ({@link isModelScopedStepSettingKey}), sorted. */
+export declare function modelScopedStepSettingKeys(bag: Readonly<Record<string, unknown>>): string[];
+/** `bag` without its model-scoped keys — what a camera layer contributes at dispatch. Fresh object. */
+export declare function cameraScopedStepSettings(bag: Readonly<Record<string, unknown>>): Record<string, unknown>;