@camstack/types 1.2.46 → 1.2.47

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-BE4PDZ_3.js");
-const require_sleep = require("./sleep-CyN9nHr_.js");
+const require_sleep = require("./sleep-ocMLM2o5.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/collection-array-methods.ts
 /**
@@ -252,8 +252,9 @@ var CAP_INPUT_DEFAULTS = Object.freeze({
 			"postSeconds": 6,
 			"kinds": ["mp4"],
 			"gifMaxWidth": 640,
-			"gifFps": 8,
-			"speed": 1
+			"gifFps": 12,
+			"gifSpeed": 4,
+			"speed": 4
 		},
 		"pullAudioChunks": { "maxCount": 8 },
 		"pullFrameHandles": { "maxCount": 4 },

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { t as EventCategory } from "./event-category-41fKf-q9.mjs";
-import { C as DeviceType, F as readNodePin, L as ReadinessRegistry, O as expandCapMethods, P as nodePin, R as ReadinessTimeoutError, V as scopeKey, a as asJsonObject, d as DEVICE_SCOPED_CAPS, f as isDeviceScopedCap, gt as normalizeAddonInitResult, ht as BaseAddon, mt as DisposerChain, p as createDeviceProxy, pt as DATAPLANE_SECRET_HEADER, s as asString, t as sleep, u as parseJsonUnknown, v as deviceOpsCapability, w as adminUiCapability, y as viewerUiCapability, yt as emitReadiness } from "./sleep-BbYwFLG6.mjs";
+import { C as DeviceType, F as readNodePin, L as ReadinessRegistry, O as expandCapMethods, P as nodePin, R as ReadinessTimeoutError, V as scopeKey, a as asJsonObject, d as DEVICE_SCOPED_CAPS, f as isDeviceScopedCap, gt as normalizeAddonInitResult, ht as BaseAddon, mt as DisposerChain, p as createDeviceProxy, pt as DATAPLANE_SECRET_HEADER, s as asString, t as sleep, u as parseJsonUnknown, v as deviceOpsCapability, w as adminUiCapability, y as viewerUiCapability, yt as emitReadiness } from "./sleep-7WqNZVcL.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/collection-array-methods.ts
 /**
@@ -251,8 +251,9 @@ var CAP_INPUT_DEFAULTS = Object.freeze({
 			"postSeconds": 6,
 			"kinds": ["mp4"],
 			"gifMaxWidth": 640,
-			"gifFps": 8,
-			"speed": 1
+			"gifFps": 12,
+			"gifSpeed": 4,
+			"speed": 4
 		},
 		"pullAudioChunks": { "maxCount": 8 },
 		"pullFrameHandles": { "maxCount": 4 },

package/dist/{fmp4-box-splitter-B53u9-Nu.mjs → canonical-hash-rO1sRmEK.mjs}

@@ -405,39 +405,6 @@ function invocationFromEncodeProfile(input) {
 	};
 }
 //#endregion
-//#region src/utils/canonical-hash.ts
-/**
-* Deterministic SHA-256 hash of an arbitrary serialisable value. The
-* canonical form sorts object keys alphabetically at every depth so two
-* structurally-equal inputs with different key insertion orders produce
-* the same hash. Returns a 64-char lowercase hex digest.
-*
-* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
-* accessory-rebuild work when the upstream shape is byte-identical to
-* the last applied state — preventing user-visible "re-discovery"
-* notifications on every addon-runner respawn. Each respawn re-fires
-* `DeviceBindingsChanged` for every cap registration, which without
-* this guard would propagate redundant pushes.
-*
-* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
-* subscription. The proper fix is a single "device ready" lifecycle
-* barrier so exports react only when the full cap set has landed —
-* tracked separately for post-HA-integration work.
-*/
-function canonicalHash(value) {
-	const canonical = JSON.stringify(value, replaceWithSortedKeys);
-	return createHash("sha256").update(canonical ?? "").digest("hex");
-}
-function replaceWithSortedKeys(_key, value) {
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const obj = value;
-		const out = {};
-		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
-		return out;
-	}
-	return value;
-}
-//#endregion
 //#region src/ffmpeg/fmp4-box-splitter.ts
 var DEFAULT_MAX_UNIT_BYTES = 16 * 1024 * 1024;
 /** Header size for a normal box, and for one carrying a 64-bit `largesize`. */
@@ -612,4 +579,37 @@ var Fmp4BoxSplitter = class {
 	}
 };
 //#endregion
-export { buildAudioArgs as a, buildVideoArgs as c, logBannerArgs as d, pickVideoEncoder as f, audioPlanFromEncodeProfile as i, invocationFromEncodeProfile as l, canonicalHash as n, buildFfmpegArgs as o, AUDIO_PRESETS as r, buildInputArgs as s, Fmp4BoxSplitter as t, isSoftwareDecode as u };
+//#region src/utils/canonical-hash.ts
+/**
+* Deterministic SHA-256 hash of an arbitrary serialisable value. The
+* canonical form sorts object keys alphabetically at every depth so two
+* structurally-equal inputs with different key insertion orders produce
+* the same hash. Returns a 64-char lowercase hex digest.
+*
+* Used by export adapters (Alexa, HAP) to short-circuit re-discovery /
+* accessory-rebuild work when the upstream shape is byte-identical to
+* the last applied state — preventing user-visible "re-discovery"
+* notifications on every addon-runner respawn. Each respawn re-fires
+* `DeviceBindingsChanged` for every cap registration, which without
+* this guard would propagate redundant pushes.
+*
+* Note: this is a SYMPTOMATIC fix layered on top of the binding-change
+* subscription. The proper fix is a single "device ready" lifecycle
+* barrier so exports react only when the full cap set has landed —
+* tracked separately for post-HA-integration work.
+*/
+function canonicalHash(value) {
+	const canonical = JSON.stringify(value, replaceWithSortedKeys);
+	return createHash("sha256").update(canonical ?? "").digest("hex");
+}
+function replaceWithSortedKeys(_key, value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const obj = value;
+		const out = {};
+		for (const k of Object.keys(obj).toSorted()) out[k] = obj[k];
+		return out;
+	}
+	return value;
+}
+//#endregion
+export { buildAudioArgs as a, buildVideoArgs as c, logBannerArgs as d, pickVideoEncoder as f, audioPlanFromEncodeProfile as i, invocationFromEncodeProfile as l, Fmp4BoxSplitter as n, buildFfmpegArgs as o, AUDIO_PRESETS as r, buildInputArgs as s, canonicalHash as t, isSoftwareDecode as u };

package/dist/capabilities/core-blocks.cap.d.ts

@@ -19,6 +19,22 @@ import { type InferProvider } from './capability-definition.js';
  * instead of taking the hub with it (D6). Every method here is admin-only, and
  * must stay so.
  */
+/**
+ * Prefix for a block's generated addon id AND its runner id — one addon, one
+ * process, so the two are the same string (D2).
+ *
+ * It lives on the CONTRACT rather than beside the code that materialises the
+ * package, because it is not an implementation detail: the operator surface
+ * reads a block's logs by asking `logs.query` for `addonId = core-block-<id>`,
+ * with no cap and no store of its own. Two copies of this string is one copy
+ * too many — a drift would show as a logs pane that is simply always empty.
+ */
+export declare const CORE_BLOCK_ADDON_PREFIX = "core-block-";
+/** The addon/runner id a block's process runs under. */
+export declare function coreBlockAddonId(blockId: string): string;
+/** The block id behind a generated addon/runner id, or null when the id belongs
+ *  to something else. The inverse of {@link coreBlockAddonId}. */
+export declare function coreBlockIdFromAddonId(addonId: string): string | null;
 /** Where a block runs. The operator chooses — a block driving a device on an
  *  agent is the reason placement is not fixed to the hub. */
 export declare const CoreBlockPlacementSchema: z.ZodUnion<readonly [z.ZodLiteral<"hub">, z.ZodString]>;
@@ -216,6 +232,42 @@ export declare const coreBlocksCapability: {
                 lastChangedAt: z.ZodNumber;
             }, z.core.$strip>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Stop this block's runner and let the supervisor bring it back.
+         *
+         * **It stores nothing.** There is no "restart requested" flag and no second
+         * lifecycle field: the supervisor already stops and respawns a runner when
+         * the code hash changes, and this exposes that same path deliberately
+         * (D62 — a switch writes the authority that already owned the function).
+         * The next reconcile pass remains the authority, so a restart that lost a
+         * race is corrected within one pass rather than leaving a stale flag behind.
+         *
+         * Refused for a DISABLED block: nothing would come back, and a button that
+         * silently does nothing is worse than one that says why.
+         */
+        readonly restart: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            blockId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            block: z.ZodObject<{
+                name: z.ZodString;
+                code: z.ZodString;
+                enabled: z.ZodBoolean;
+                placement: z.ZodUnion<readonly [z.ZodLiteral<"hub">, z.ZodString]>;
+                integrationId: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+                createdBy: z.ZodString;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    running: "running";
+                    stopped: "stopped";
+                    starting: "starting";
+                }>;
+                lastError: z.ZodOptional<z.ZodString>;
+                lastChangedAt: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, "mutation">;
         /**
          * Type-check without saving — what the editor calls as the author types, so
          * the compiler's verdict is the same one the server will reach.