@camstack/types 1.2.26 → 1.2.28

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-BvSjpsfC.js");
+const require_sleep = require("./sleep-6oDIDtYV.js");
 const require_event_category = require("./event-category-BE4PDZ_3.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -4857,6 +4857,69 @@ var NcZoneConditionSchema = zod.z.object({
 * membership lists are OR within the list (spec §2.3).
 */
 /**
+* What a rule may actuate.
+*
+* **No hand-maintained allowlist** (operator decision, and the right one — a
+* written list of methods is a third parallel map to keep aligned, and this
+* repo has paid for those). The boundary instead comes from a property the
+* capabilities already carry: an action may target only a **device-scoped**
+* capability method.
+*
+* That is not decoration. A rule can be authored by a NON-ADMIN — personal
+* rules are a supported flow — and the executor runs with the addon's
+* privileges, so an unbounded action is an arbitrary RPC channel with a
+* privilege escalation attached. Restricting to device scope excludes the
+* system caps (`device-manager.removeDevice` and friends) by construction,
+* costs nothing to maintain, and cannot rot: a cap that stops being
+* device-scoped stops being actuatable in the same change.
+*
+* The executor enforces it; {@link NcRuleActionSchema} carries the intent.
+*/
+/**
+* One step of a sequence.
+*
+* `wait` is a first-class step rather than a property of the next action: it is
+* what makes a sequence a SEQUENCE and not a list — "unlock, wait 5s, open"
+* cannot be expressed otherwise.
+*/
+var NcRuleActionSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("wait"),
+	seconds: zod.z.number().min(0).max(300)
+}), zod.z.object({
+	kind: zod.z.literal("cap"),
+	deviceId: zod.z.number().int(),
+	/** Capability name, e.g. `alarm-panel`. */
+	cap: zod.z.string().min(1),
+	/** Method on it. The executor refuses a non-device-scoped cap. */
+	method: zod.z.string().min(1),
+	/** Method arguments, minus `deviceId` (the executor injects it). */
+	args: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+})]);
+/**
+* A named, ordered run of steps with its own throttle.
+*
+* `minDelaySec` exists because a noisy rule otherwise hammers a physical
+* actuator — the rule's own cooldown governs NOTIFICATIONS, which is a
+* different budget from "how often may this gate actually open".
+*/
+var NcRuleActionSequenceSchema = zod.z.object({
+	name: zod.z.string().min(1).max(120),
+	enabled: zod.z.boolean(),
+	minDelaySec: zod.z.number().int().min(0).max(86400).optional(),
+	actions: zod.z.array(NcRuleActionSchema).min(1)
+});
+/**
+* Sequences a rule runs, by hook point.
+*
+* ONLY `onTrigger` is here, deliberately. The reference also has activation /
+* deactivation / reset / post-generation hooks, and they are wanted — but this
+* repo's expensive failure mode is declaring a surface nothing produces, so a
+* hook appears here in the same change that produces its edge, never before.
+*/
+var NcRuleActionsSchema = zod.z.object({ 
+/** Runs when the rule MATCHES. */
+onTrigger: zod.z.array(NcRuleActionSequenceSchema).optional() });
+/**
 * "This rule applies only while `deviceId` is in one of `states`."
 *
 * The states are the DEVICE's own vocabulary — `AlarmState` for a panel,
@@ -5167,7 +5230,16 @@ var NcRuleInputSchema = zod.z.object({
 	* read as `false` by {@link canSetGlobal} in the engine. Admins are not bound
 	* by this flag — see the scope rules on that function.
 	*/
-	snoozeAllowGlobal: zod.z.boolean().optional()
+	snoozeAllowGlobal: zod.z.boolean().optional(),
+	/**
+	* Devices this rule ACTUATES — arm the alarm, open a gate, turn on a light.
+	*
+	* This is what makes the rule set the alarm's trigger set without the alarm
+	* being a special case: arming is
+	* `{ cap: 'alarm-panel', method: 'arm', args: { mode: 'away' } }`, the same
+	* shape as every other actuation.
+	*/
+	actions: NcRuleActionsSchema.optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -14900,6 +14972,16 @@ function createSystemProxy(api) {
 			getState: (input) => dispatch("broker", "getState", "query", input),
 			getStatus: (input) => dispatch("broker", "getStatus", "query", input)
 		},
+		coreBlocks: {
+			list: (input) => dispatch("coreBlocks", "list", "query", input),
+			get: (input) => dispatch("coreBlocks", "get", "query", input),
+			create: (input) => dispatch("coreBlocks", "create", "mutation", input),
+			update: (input) => dispatch("coreBlocks", "update", "mutation", input),
+			delete: (input) => dispatch("coreBlocks", "delete", "mutation", input),
+			setEnabled: (input) => dispatch("coreBlocks", "setEnabled", "mutation", input),
+			compile: (input) => dispatch("coreBlocks", "compile", "mutation", input),
+			getTypeDefs: (input) => dispatch("coreBlocks", "getTypeDefs", "query", input)
+		},
 		decoder: {
 			supportsCodec: (input) => dispatch("decoder", "supportsCodec", "query", input),
 			getInfo: (input) => dispatch("decoder", "getInfo", "query", input),
@@ -20720,6 +20802,137 @@ var notificationOutputCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/core-blocks.cap.ts
+/**
+* core-blocks — user-authored TypeScript, stored in the kernel and executed in
+* its own process.
+*
+* Spec: `docs/superpowers/specs/2026-08-04-core-blocks-and-synthetic-devices-design.md`.
+*
+* The first use is **owning devices without being a device provider**: a block
+* declares devices under a system or custom integration and drives their state,
+* with the same `ctx` an addon gets. Automations come later; nothing here
+* models a trigger.
+*
+* **Stated plainly, because it does not change by being true:** a block has an
+* addon's powers — devices, storage, the event bus, `ctx.api`. It is a plugin
+* with no review step. What makes that survivable is not a sandbox, it is
+* PROCESS ISOLATION: one process per block, supervised by `CrashSupervisor`,
+* so a block that throws or never returns is marked `failed` and visible
+* instead of taking the hub with it (D6). Every method here is admin-only, and
+* must stay so.
+*/
+/** 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. */
+var CoreBlockPlacementSchema = zod.z.union([zod.z.literal("hub"), zod.z.string().min(1)]);
+/** What a block's process is doing. Mirrors the addon runner's own lifecycle so
+*  a failing block reads the same way a failing addon does. */
+var CoreBlockStatusSchema = zod.z.enum([
+	"stopped",
+	"starting",
+	"running",
+	"failed"
+]);
+/** Client-authored fields. */
+var CoreBlockInputSchema = zod.z.object({
+	name: zod.z.string().min(1).max(120),
+	/** TypeScript source. Compiled server-side before it is ever stored — a
+	*  block that does not compile is a fork failure the operator would meet
+	*  minutes later, in a log, instead of in the editor. */
+	code: zod.z.string().max(2e5),
+	enabled: zod.z.boolean(),
+	placement: CoreBlockPlacementSchema,
+	/**
+	* Integration the block's devices hang from. Absent = the system integration
+	* blocks share. A block may declare its own instead.
+	*/
+	integrationId: zod.z.string().optional()
+});
+/** A stored block. */
+var CoreBlockSchema = CoreBlockInputSchema.extend({
+	id: zod.z.string(),
+	createdAt: zod.z.number(),
+	updatedAt: zod.z.number(),
+	/** Server-stamped author. */
+	createdBy: zod.z.string(),
+	status: CoreBlockStatusSchema,
+	/**
+	* Why the block is not running, when it is not. The operator's ONLY window
+	* into a block that failed at load — a block that is silently absent is the
+	* failure mode this whole feature has to avoid.
+	*/
+	lastError: zod.z.string().optional(),
+	/** Ms epoch of the last state change. */
+	lastChangedAt: zod.z.number()
+});
+/** What a compile attempt produced. */
+var CoreBlockCompileResultSchema = zod.z.object({
+	ok: zod.z.boolean(),
+	/** Present when `ok` is false — the first error, in the author's words. */
+	error: zod.z.string().optional(),
+	line: zod.z.number().optional(),
+	column: zod.z.number().optional()
+});
+var coreBlocksCapability = {
+	name: "core-blocks",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		list: require_sleep.method(zod.z.object({}), zod.z.object({ blocks: zod.z.array(CoreBlockSchema) }), { auth: "admin" }),
+		get: require_sleep.method(zod.z.object({ blockId: zod.z.string() }), zod.z.object({ block: CoreBlockSchema.nullable() }), { auth: "admin" }),
+		/**
+		* Create a block. The code is COMPILED first: storing source that does not
+		* compile turns an editor error into a fork failure the operator meets
+		* minutes later in a log.
+		*/
+		create: require_sleep.method(zod.z.object({ block: CoreBlockInputSchema }), zod.z.object({ block: CoreBlockSchema }), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		update: require_sleep.method(zod.z.object({
+			blockId: zod.z.string(),
+			block: CoreBlockInputSchema.partial()
+		}), zod.z.object({ block: CoreBlockSchema }), {
+			kind: "mutation",
+			auth: "admin",
+			caller: "required"
+		}),
+		delete: require_sleep.method(zod.z.object({ blockId: zod.z.string() }), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		setEnabled: require_sleep.method(zod.z.object({
+			blockId: zod.z.string(),
+			enabled: zod.z.boolean()
+		}), zod.z.object({ block: CoreBlockSchema }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* 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.
+		*/
+		compile: require_sleep.method(zod.z.object({ code: zod.z.string() }), CoreBlockCompileResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* The declaration files the editor type-checks against.
+		*
+		* Served rather than bundled: the graph is 3.4 MB across 344 files, and
+		* bundling it would roughly double the admin remote. Served rather than
+		* hand-stubbed: a block runs with the same `ctx` an addon gets, so a stub
+		* would drift and the editor would confidently autocomplete methods that
+		* do not exist.
+		*/
+		getTypeDefs: require_sleep.method(zod.z.object({}), zod.z.object({ libs: zod.z.array(zod.z.object({
+			filePath: zod.z.string(),
+			content: zod.z.string()
+		})) }), { auth: "admin" })
+	}
+};
+//#endregion
 //#region src/schemas/auth-records.ts
 /**
 * Zod schemas for persisted record types.
@@ -27388,6 +27601,7 @@ var CAPABILITY_NAMES = {
 	consumables: "consumables",
 	contact: "contact",
 	control: "control",
+	coreBlocks: "core-blocks",
 	cover: "cover",
 	customModelRegistry: "custom-model-registry",
 	dataStoreProvider: "data-store-provider",
@@ -27640,6 +27854,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "control",
 		name: "control"
 	},
+	{
+		key: "coreBlocks",
+		name: "core-blocks"
+	},
 	{
 		key: "cover",
 		name: "cover"
@@ -28122,6 +28340,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	consumablesCapability,
 	contactCapability,
 	controlCapability,
+	coreBlocksCapability,
 	coverCapability,
 	customModelRegistryCapability,
 	dataStoreProviderCapability,
@@ -29098,6 +29317,54 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"coreBlocks.compile": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"coreBlocks.create": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"coreBlocks.delete": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"coreBlocks.get": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"coreBlocks.getTypeDefs": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"coreBlocks.list": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"coreBlocks.setEnabled": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"coreBlocks.update": {
+		capName: "core-blocks",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"cover.close": {
 		capName: "cover",
 		capScope: "device",
@@ -33407,6 +33674,7 @@ var KNOWN_CAP_NAMES = [
 	"color",
 	"consumables",
 	"control",
+	"core-blocks",
 	"cover",
 	"custom-model-registry",
 	"data-store-provider",
@@ -33571,6 +33839,7 @@ var SYSTEM_CAP_NAMES = [
 	"auth-provider",
 	"backup",
 	"broker",
+	"core-blocks",
 	"custom-model-registry",
 	"data-store-provider",
 	"decoder",
@@ -34368,6 +34637,11 @@ exports.ControlStatusSchema = ControlStatusSchema;
 exports.ConvertArtifactSchema = ConvertArtifactSchema;
 exports.ConvertResultSchema = ConvertResultSchema;
 exports.ConvertTargetSchema = ConvertTargetSchema;
+exports.CoreBlockCompileResultSchema = CoreBlockCompileResultSchema;
+exports.CoreBlockInputSchema = CoreBlockInputSchema;
+exports.CoreBlockPlacementSchema = CoreBlockPlacementSchema;
+exports.CoreBlockSchema = CoreBlockSchema;
+exports.CoreBlockStatusSchema = CoreBlockStatusSchema;
 exports.CoverStateSchema = CoverStateSchema;
 exports.CoverStatusSchema = CoverStatusSchema;
 exports.CreateApiKeyInputSchema = CreateApiKeyInputSchema;
@@ -34389,6 +34663,7 @@ exports.DEFAULT_SCRUB_THUMBNAIL_PRESET = DEFAULT_SCRUB_THUMBNAIL_PRESET;
 exports.DEVICE_BACKEND_TO_FORMAT = DEVICE_BACKEND_TO_FORMAT;
 exports.DEVICE_CAP_NAMES = DEVICE_CAP_NAMES;
 exports.DEVICE_PROFILES = DEVICE_PROFILES;
+exports.DEVICE_SCOPED_CAPS = require_sleep.DEVICE_SCOPED_CAPS;
 exports.DEVICE_SETTINGS_CONTRIBUTION_METHODS = require_sleep.DEVICE_SETTINGS_CONTRIBUTION_METHODS;
 exports.DEVICE_STATE_READERS = DEVICE_STATE_READERS;
 exports.DEVICE_STATUS_METHOD = require_sleep.DEVICE_STATUS_METHOD;
@@ -34612,6 +34887,9 @@ exports.NcMediaFrameSchema = NcMediaFrameSchema;
 exports.NcMediaPolicySchema = NcMediaPolicySchema;
 exports.NcOccupancyConditionSchema = NcOccupancyConditionSchema;
 exports.NcPlateMatcherSchema = NcPlateMatcherSchema;
+exports.NcRuleActionSchema = NcRuleActionSchema;
+exports.NcRuleActionSequenceSchema = NcRuleActionSequenceSchema;
+exports.NcRuleActionsSchema = NcRuleActionsSchema;
 exports.NcRuleInputSchema = NcRuleInputSchema;
 exports.NcRulePatchSchema = NcRulePatchSchema;
 exports.NcRuleSchema = NcRuleSchema;
@@ -34948,6 +35226,7 @@ exports.consumablesCapability = consumablesCapability;
 exports.contactCapability = contactCapability;
 exports.controlCapability = controlCapability;
 exports.convertUnit = convertUnit;
+exports.coreBlocksCapability = coreBlocksCapability;
 exports.cosineSimilarity = cosineSimilarity;
 exports.coverCapability = coverCapability;
 exports.createDeviceProxy = require_sleep.createDeviceProxy;
@@ -35028,6 +35307,7 @@ exports.isBaseConditionKey = isBaseConditionKey;
 exports.isCollectionArrayMethod = isCollectionArrayMethod;
 exports.isDeployableToAgent = isDeployableToAgent;
 exports.isDeviceConfigCap = require_sleep.isDeviceConfigCap;
+exports.isDeviceScopedCap = require_sleep.isDeviceScopedCap;
 exports.isEvent = require_sleep.isEvent;
 exports.isNode = isNode;
 exports.isObjectInput = isObjectInput;