@camstack/system 1.2.313 → 1.2.315

package/dist/addon-runner.js

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_child_cap_dispatch = require("./child-cap-dispatch-Dyn_7ezH.js");
+const require_child_cap_dispatch = require("./child-cap-dispatch-DzcUd_ct.js");
 const require_custom_action_registry = require("./custom-action-registry-acBY3mHA.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);

package/dist/addon-runner.mjs

@@ -1,4 +1,4 @@
-import { H as createUdsLoggerWithControl, Mt as installManifestNativeDeps, Nt as resolveAddonClass, Sn as emitHeapDiagnosticReport, Y as LocalChildClient, Zt as RUNNER_RSS_BUDGET_ENV, _t as setWorkerNativeCapsChangeListener, f as installManifestSystemDeps, g as createUdsAddonContext, ht as getWorkerNativeCapSnapshot, i as killOwnRunnerGroupAfterParentLoss, mt as getWorkerNativeCapProvider, n as createChildCapDispatch, p as installManifestPythonDeps, u as startRunnerParentDeathWatchdog, un as startRunnerHeapWatch, yt as validateProviderRegistrations } from "./child-cap-dispatch-CHTiHbsv.mjs";
+import { $t as RUNNER_RSS_BUDGET_ENV, Ft as resolveAddonClass, H as createUdsLoggerWithControl, Pt as installManifestNativeDeps, U as LocalChildClient, _t as getWorkerNativeCapSnapshot, f as installManifestSystemDeps, fn as startRunnerHeapWatch, g as createUdsAddonContext, gt as getWorkerNativeCapProvider, i as killOwnRunnerGroupAfterParentLoss, n as createChildCapDispatch, p as installManifestPythonDeps, u as startRunnerParentDeathWatchdog, wn as emitHeapDiagnosticReport, xt as validateProviderRegistrations, yt as setWorkerNativeCapsChangeListener } from "./child-cap-dispatch-AAltfBUH.mjs";
 import { t as CustomActionRegistry } from "./custom-action-registry-B4Cf4O_X.mjs";
 import { register } from "node:module";
 import * as path$1 from "node:path";

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CkRwnhbo.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");

package/dist/builtins/addon-pages-aggregator/addon-pages-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { R as addonPagesCapability, ir as EventCategory, jn as BaseAddon, kn as errMsg } from "../../dist-Cj7pJmXq.mjs";
+import { Gn as BaseAddon, R as addonPagesCapability, Wn as errMsg, hr as EventCategory } from "../../dist-MzYJVCLE.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as path$1 from "node:path";

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CkRwnhbo.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
 const require_settle_sources = require("../../settle-sources-Bhsy57y-.js");
 let node_crypto = require("node:crypto");
 let node_path = require("node:path");

package/dist/builtins/addon-widgets-aggregator/addon-widgets-aggregator.addon.mjs

@@ -1,4 +1,4 @@
-import { B as addonWidgetsCapability, ir as EventCategory, jn as BaseAddon, kn as errMsg } from "../../dist-Cj7pJmXq.mjs";
+import { B as addonWidgetsCapability, Gn as BaseAddon, Wn as errMsg, hr as EventCategory } from "../../dist-MzYJVCLE.mjs";
 import { t as settleSourcesWithTimeout } from "../../settle-sources-CDtNC8ub.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import * as path$1 from "node:path";

package/dist/builtins/alerts/alerts.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CkRwnhbo.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,4 @@
-import { V as alertsCapability, Wn as createEvent, ir as EventCategory, jn as BaseAddon, kn as errMsg, n as AlertSchema } from "../../dist-Cj7pJmXq.mjs";
+import { Gn as BaseAddon, V as alertsCapability, Wn as errMsg, hr as EventCategory, n as AlertSchema, tr as createEvent } from "../../dist-MzYJVCLE.mjs";
 //#region src/builtins/alerts/prune-policy.ts
 /**
 * Ids older than `cutoffMs`, oldest first.

package/dist/builtins/autotrack/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CkRwnhbo.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
 //#region src/builtins/autotrack/autotrack-config.ts
 var DEFAULT_AUTOTRACK_LOOP_CONFIG = {
 	deadZoneFraction: .5,

package/dist/builtins/autotrack/index.mjs

@@ -1,4 +1,4 @@
-import { W as bareAddonId, Xn as isEvent, in as ptzAutotrackCapability, ir as EventCategory, jn as BaseAddon, kn as errMsg, v as FIRST_LEVEL_MACRO_CLASSES } from "../../dist-Cj7pJmXq.mjs";
+import { $t as ptzAutotrackCapability, Gn as BaseAddon, W as bareAddonId, Wn as errMsg, _ as FIRST_LEVEL_MACRO_CLASSES, hr as EventCategory, sr as isEvent } from "../../dist-MzYJVCLE.mjs";
 //#region src/builtins/autotrack/autotrack-config.ts
 var DEFAULT_AUTOTRACK_LOOP_CONFIG = {
 	deadZoneFraction: .5,

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CkRwnhbo.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
 let node_crypto = require("node:crypto");
 let buffer = require("buffer");
 let node_fs_promises = require("node:fs/promises");

package/dist/builtins/backup-orchestrator/backup-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { U as backupCapability, ir as EventCategory, jn as BaseAddon, qt as mayWriteToLocation, vn as storageOccupancyCapability } from "../../dist-Cj7pJmXq.mjs";
+import { Gn as BaseAddon, Ht as mayWriteToLocation, U as backupCapability, hr as EventCategory, mn as storageOccupancyCapability } from "../../dist-MzYJVCLE.mjs";
 import { randomBytes, randomUUID } from "node:crypto";
 import { Buffer as Buffer$1 } from "buffer";
 import * as fsp from "node:fs/promises";

package/dist/builtins/camera-grid/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-CkRwnhbo.js");
+const require_dist = require("../../dist-DVKv5i-e.js");
 let zod = require("zod");
 let _camstack_types_node = require("@camstack/types/node");
 let node_path = require("node:path");

package/dist/builtins/camera-grid/index.mjs

@@ -1,4 +1,4 @@
-import { An as buildFfmpegArgs, Fn as DeviceFeature, J as cameraGridLayoutCapability, Jn as hydrateSchema, Ln as DeviceType, Wn as createEvent, Xt as motionCapability, bn as streamCatalogCapability, g as DeclaredDevices, h as DERIVED_CAMERA_SILENCED_CAP_NAMES, hn as snapshotCapability, i as BaseDevice, ir as EventCategory, jn as BaseAddon, kn as errMsg, lt as declarationOwnerNodeId, w as MOTION_CLOSE_AFTER_MS } from "../../dist-Cj7pJmXq.mjs";
+import { Gn as BaseAddon, Gt as motionCapability, J as cameraGridLayoutCapability, T as MOTION_CLOSE_AFTER_MS, Un as DeviceType, Vn as DeviceFeature, Wn as errMsg, ar as hydrateSchema, dn as snapshotCapability, gn as streamCatalogCapability, h as DeclaredDevices, hr as EventCategory, i as BaseDevice, kn as buildFfmpegArgs, m as DERIVED_CAMERA_SILENCED_CAP_NAMES, ot as declarationOwnerNodeId, tr as createEvent } from "../../dist-MzYJVCLE.mjs";
 import { z } from "zod";
 import { FfmpegProcess } from "@camstack/types/node";
 import { join } from "node:path";

package/dist/builtins/composer/claim-gate.d.ts

@@ -0,0 +1,32 @@
+import { FieldClaim, IScopedLogger } from '@camstack/types';
+export interface ClaimKey {
+    readonly deviceId: number;
+    readonly capName: string;
+    readonly owner: string;
+}
+export declare function claimKey(k: ClaimKey): string;
+export declare class ClaimGate {
+    private readonly logger;
+    private known;
+    constructor(logger: IScopedLogger);
+    /**
+     * The claims the hub holds before this process applied anything. Called once
+     * at boot, before the first `filter`. A claim the gate already knows keeps its
+     * entry and its miss count.
+     */
+    seed(claims: readonly FieldClaim[]): void;
+    /** Every claim known under one owner — what a block whose plan is held keeps (D659 placeholder rule). */
+    claimsOf(owner: string): readonly ClaimKey[];
+    /**
+     * Learn `wanted` and answer the claims to release NOW: those absent from
+     * `wanted` on two consecutive calls, plus those whose earlier release the hub
+     * has not confirmed yet. A claim wanted again starts from zero misses.
+     */
+    filter(wanted: readonly ClaimKey[]): readonly ClaimKey[];
+    /** The hub confirmed the release (or held nothing of ours): forgotten. */
+    released(key: ClaimKey, how: string): void;
+    /** The release did not land: kept, and returned by every later `filter` until it does. Never given up. */
+    releaseFailed(key: ClaimKey, error: string): void;
+    private tagsOf;
+    private metaOf;
+}

package/dist/builtins/composer/composed-device-set.d.ts

@@ -0,0 +1,38 @@
+import { DeviceDeclaration, IScopedLogger } from '@camstack/types';
+import { ComposedDeviceHandle } from './composed-device.js';
+import { ComposerDerivedSpec, PlannedBlock } from './composer-plan.js';
+import { PersistedComposedRow } from './composition-declarations.js';
+export interface ComposerDevicePorts {
+    setName(deviceId: number, name: string): Promise<void>;
+    decommission(deviceId: number): Promise<void>;
+    applyDerivedSpec(deviceId: number, derived: ComposerDerivedSpec): Promise<void>;
+}
+export interface ComposerDeclareResult {
+    /** Live composed devices by stableId. */
+    readonly devices: ReadonlyMap<string, ComposedDeviceHandle>;
+}
+export type ComposerDeclare = (integrationId: string, devices: readonly DeviceDeclaration[]) => Promise<ComposerDeclareResult>;
+export interface ComposedDeviceSetDeps {
+    readonly logger: IScopedLogger;
+    readonly declare: ComposerDeclare;
+    readonly devices: ComposerDevicePorts;
+}
+/** What `rebuildShapes` needs of a block's previous apply: its live device and the shape it was built for. */
+export interface PreviousShape {
+    readonly device: ComposedDeviceHandle | null;
+    readonly shape: string | null;
+}
+export declare class ComposedDeviceSet {
+    private readonly deps;
+    private devices;
+    private existingRows;
+    private declaredFingerprint;
+    constructor(deps: ComposedDeviceSetDeps);
+    /** StableIds whose row exists. */
+    get rows(): ReadonlySet<string>;
+    seedRows(rows: readonly PersistedComposedRow[]): void;
+    get(stableId: string): ComposedDeviceHandle | null;
+    idOf(stableId: string): number | null;
+    rebuildShapes(planned: readonly PlannedBlock[], previousOf: (blockId: string) => PreviousShape | undefined): Promise<ReadonlyMap<string, string>>;
+    reconcile(integrationId: string, declarations: readonly DeviceDeclaration[], planned: readonly PlannedBlock[]): Promise<void>;
+}

package/dist/builtins/composer/composed-device.d.ts

@@ -1,6 +1,7 @@
-import { BaseDevice, CapabilityDefinition, DeviceConstructor, DeviceContext, DeviceFeature, DeviceType, ExpressionValue, IDevice } from '@camstack/types';
+import { BaseDevice, CapabilityDefinition, DeviceConstructor, DeviceContext, DeviceFeature, DeviceType, IDevice } from '@camstack/types';
 import { z } from 'zod';
 import { ComposedWriteTarget, WriteOutcome } from './composition-runtime.js';
+import { SlicePatch } from './slice-assembler.js';
 declare const COMPOSED_DEVICE_CONFIG_SCHEMA: z.ZodObject<{}, z.core.$strip>;
 export interface ComposedDeviceHandle extends ComposedWriteTarget {
     readonly name: string;
@@ -8,8 +9,8 @@ export interface ComposedDeviceHandle extends ComposedWriteTarget {
 export declare class ComposedDevice extends BaseDevice<typeof COMPOSED_DEVICE_CONFIG_SCHEMA> implements ComposedDeviceHandle {
     readonly features: readonly DeviceFeature[];
     constructor(ctx: DeviceContext, type: DeviceType, caps: readonly CapabilityDefinition[]);
-    seed(capName: string, slice: Readonly<Record<string, ExpressionValue>>): WriteOutcome;
-    patch(capName: string, patch: Readonly<Record<string, ExpressionValue>>): WriteOutcome;
+    seed(capName: string, slice: SlicePatch): WriteOutcome;
+    patch(capName: string, patch: SlicePatch): WriteOutcome;
     setAvailable(available: boolean): void;
 }
 export declare function composedDeviceClass(type: DeviceType, caps: readonly CapabilityDefinition[]): DeviceConstructor<ComposedDevice>;

package/dist/builtins/composer/composer-grafts.d.ts

@@ -0,0 +1,54 @@
+import { CompositionFeaturePlan, CompositionSourceRef, IScopedLogger } from '@camstack/types';
+import { ComposerGraftPorts, DescribeTarget } from './existing-target.js';
+/** A foreign native now serves the grafted cap: the claim stays (Task 10 rule 2). */
+export declare const NATIVE_APPEARED_UNGRAFT_REASON = "a native provider appeared";
+/** The block's add claim was released by the D49 gate (deleted, disabled, feature removed): its graft goes with it. */
+export declare const NO_LONGER_ADDED_UNGRAFT_REASON = "the block no longer adds this cap";
+/** A binding a previous composer process left, that nothing wants any more (I-3). */
+export declare const STALE_GRAFT_RETRACT_REASON = "a graft left by a previous composer process that no plan wants";
+/** The `device.bindings-changed` facts the graft decisions read. */
+export interface BindingsChangeFacts {
+    readonly deviceId: number;
+    readonly capName: string;
+    readonly reason: string;
+    readonly addonId: string;
+}
+export interface GraftPlanInput {
+    readonly deviceId: number;
+    readonly ref: CompositionSourceRef;
+    readonly features: readonly CompositionFeaturePlan[];
+    /** The description the plan used: cap → the addon serving it (`getBindings`). */
+    readonly nativeCaps: ReadonlyMap<string, string>;
+    readonly enabled: boolean;
+    /** Planned without problems; a block whose plan failed holds what it has (rule 4). */
+    readonly settled: boolean;
+}
+/** What a block's added caps say about its verdict: null when every one is served. */
+export interface GraftVerdict {
+    /** Nothing the block adds can be served. */
+    readonly allUnserved: boolean;
+    readonly reason: string;
+}
+export declare class ComposerGrafts {
+    private readonly ports;
+    private readonly logger;
+    private readonly readBindings;
+    /** Per device: the added caps no graft serves, and why. Reset by each plan of that device. */
+    private unserved;
+    /** Per DESCRIBED device: foreign natives registered since its description was read (cap → addonId). */
+    private foreignSince;
+    constructor(ports: ComposerGraftPorts | undefined, logger: IScopedLogger, readBindings: DescribeTarget);
+    /** A description of `deviceId` is about to be read: it covers every registration before now. */
+    describing(deviceId: number): void;
+    onBindingsChanged(data: BindingsChangeFacts): void;
+    /** Rule 2, at plan time only: graft what the plan adds; ungraft what it finds native; retract what a previous process left. */
+    plan(input: GraftPlanInput): void;
+    /** The gate released a claim: a graft of that cap goes with it; a previous process's binding is retracted once read as the composer's. */
+    released(deviceId: number, capName: string): Promise<void>;
+    /** The target row is gone: nothing about it is reported any more. */
+    gone(deviceId: number): void;
+    verdict(deviceId: number, features: readonly CompositionFeaturePlan[]): GraftVerdict | null;
+    private retractUnwanted;
+    private remember;
+    private setUnserved;
+}

package/dist/builtins/composer/composer-plan.d.ts

@@ -0,0 +1,96 @@
+import { CapabilityLookup, ComposerBlock, ComposerUnreadableBlock, CompositionExistingTarget, CompositionEventPlan, CompositionFeaturePlan, CompositionFieldPlan, CompositionNewTarget, CompositionSourceRef, DeviceDeclaration, DeviceType, IScopedLogger, LogTags } from '@camstack/types';
+import { TargetDescriptions } from './existing-target.js';
+import { SourceResolution } from './source-tracker.js';
+/** What the apply knows of a block besides its plan. `name` is null for an unreadable row whose name is unreadable too. */
+export interface PlannedBlockMeta {
+    readonly id: string;
+    readonly name: string | null;
+    readonly enabled: boolean;
+    readonly updatedAt: number;
+}
+export interface ComposerDerivedSpec {
+    readonly type: DeviceType;
+    readonly role?: string;
+}
+export interface PlannedNewTarget {
+    readonly kind: 'new';
+}
+/** A row that does not parse names no target: its claims, if any, are held (D49). */
+export interface PlannedUnreadableTarget {
+    readonly kind: 'unreadable';
+}
+export interface PlannedExistingTarget {
+    readonly kind: 'existing';
+    readonly ref: CompositionSourceRef;
+    /** The target row's id once resolved; null until then. */
+    readonly deviceId: number | null;
+    /** Why the block is `starting` rather than planned: claims unseeded, target unresolved or undescribed. Nothing is claimed. */
+    readonly waiting: string | null;
+    /** The target row is gone — two index reads agreed (rule 5). Sticky until an operator edit or restart. */
+    readonly gone: string | null;
+    readonly features: readonly CompositionFeaturePlan[];
+    /** The description the plan used: cap → the addon serving it; empty until described. */
+    readonly nativeCaps: ReadonlyMap<string, string>;
+}
+export type PlannedTarget = PlannedNewTarget | PlannedUnreadableTarget | PlannedExistingTarget;
+export interface PlannedBlock {
+    readonly block: PlannedBlockMeta;
+    readonly fields: readonly CompositionFieldPlan[];
+    readonly events: readonly CompositionEventPlan[];
+    readonly problems: readonly string[];
+    readonly declaration: DeviceDeclaration | null;
+    /** What forces a rebuild of the live device; null when nothing is declared. */
+    readonly shape: string | null;
+    readonly spec: ComposerDerivedSpec | null;
+    readonly target: PlannedTarget;
+}
+/**
+ * A row that exists but does not parse is held exactly like a composition
+ * that stopped planning: its device (if it has a row) stays as an offline
+ * placeholder, its claims (if any) are kept, and the block fails naming the
+ * parse error. Absent, it would be withdrawn on the second apply that omitted
+ * it (D49).
+ */
+export declare function planUnreadable(block: ComposerUnreadableBlock, rows: ReadonlySet<string>): PlannedBlock;
+/** `target` is the block's own `new` target, narrowed by the caller: this path never sees an existing one (M-5). */
+export declare function planNew(block: ComposerBlock, target: CompositionNewTarget, lookupCap: CapabilityLookup, rows: ReadonlySet<string>): PlannedBlock;
+/** The tracker's resolution path, as `planExisting` needs it (rule 1). */
+export interface TargetResolver {
+    resolve(ref: CompositionSourceRef, reset: boolean): Promise<SourceResolution>;
+}
+export interface ExistingPlanInput {
+    readonly block: ComposerBlock;
+    readonly target: CompositionExistingTarget;
+    /** The block's previous plan, if it is live. */
+    readonly previous: PlannedBlock | undefined;
+    /** An edit, a restart, or the block's first appearance: the only things that re-plan a settled block. */
+    readonly operatorAction: boolean;
+    /** Why the claims index is not seeded yet, else null. */
+    readonly claimsWait: string | null;
+    readonly tracker: TargetResolver;
+    readonly targets: TargetDescriptions;
+    readonly lookupCap: CapabilityLookup;
+}
+export declare function planExisting(input: ExistingPlanInput): Promise<PlannedBlock>;
+/**
+ * Runtime preparation can still fail after a complete existing-target plan.
+ * Preserve its fields and description for retry, but mark it waiting so claim
+ * reconciliation cannot treat the unprepared candidate as live.
+ */
+export declare function withExistingTargetWait(p: PlannedBlock, waiting: string): PlannedBlock;
+/** A target the previous plan held live on `deviceId`, that this plan finds gone. */
+export interface LostTarget {
+    readonly target: PlannedExistingTarget;
+    readonly deviceId: number;
+}
+/**
+ * Rule 5 on the PLAN path: `device.unregistered` is telemetry and may be
+ * dropped (D8), so a target is often found gone by the operator's next edit or
+ * restart. The previous live target is what must be ungrafted — exactly as on
+ * the event path. Null when nothing was lost by THIS plan.
+ */
+export declare function lostTarget(p: PlannedBlock, previous: PlannedBlock | undefined): LostTarget | null;
+/** Two plans write the same place: both new, or the very same existing-target plan (reused until the operator acts). */
+export declare function sameTarget(a: PlannedTarget, b: PlannedTarget): boolean;
+/** One line when a block starts or stops planning (or waiting, or loses its target) — never one per apply. */
+export declare function logPlanTransition(logger: IScopedLogger, previous: PlannedBlock | undefined, p: PlannedBlock, liveTags: LogTags): void;

package/dist/builtins/composer/composer-verdict.d.ts

@@ -0,0 +1,19 @@
+import { ComposerBlockVerdict, CompositionFieldState } from '@camstack/types';
+import { ComposedDeviceHandle } from './composed-device.js';
+import { PlannedBlock } from './composer-plan.js';
+import { CompositionRuntime } from './composition-runtime.js';
+import { GraftVerdict } from './composer-grafts.js';
+/** A runtime built by an apply, before the apply's sync decides whether it may start. */
+export declare const NOT_STARTED = "the runtime has not started yet";
+export interface LiveComposition {
+    readonly planned: PlannedBlock;
+    /** The composed device of a `new` target; null for an existing one. */
+    readonly device: ComposedDeviceHandle | null;
+    readonly runtime: CompositionRuntime | null;
+    readonly appliedName: string | null;
+    /** Why the device could not be rebuilt for a new shape; the previous one is kept. */
+    readonly rebuildError: string | null;
+    /** Rule 4: the last values of a customization that stopped planning, reported stale. */
+    readonly heldFields: readonly CompositionFieldState[];
+}
+export declare function verdictOf(blockId: string, entry: LiveComposition | undefined, unsynced: boolean, grafts?: GraftVerdict | null): ComposerBlockVerdict;