@camstack/types 1.2.27 → 1.2.29

package/dist/index.js

@@ -14972,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),
@@ -19045,8 +19055,30 @@ var deviceManagerCapability = {
 		}),
 		/** List persisted devices for an addon (DB, for restore). */
 		listPersistedByAddon: require_sleep.method(zod.z.object({ addonId: zod.z.string() }), zod.z.array(SavedDeviceRowSchema)),
-		/** List all devices (live registry), optionally filtered by addonId. */
-		listAll: require_sleep.method(zod.z.object({ addonId: zod.z.string().optional() }), zod.z.array(DeviceInfoSchema)),
+		/**
+		* List all devices (live registry), optionally filtered by addonId.
+		*
+		* **Ask for `projection: 'slim'` unless you need `config`.** A full listing
+		* of 293 devices measured 271 KB, of which `config` was 113 KB and
+		* `metadata` 22 KB — half the payload — and the viewer's camera list, the
+		* largest consumer, reads 1.8 KB of it. Worse, the persisted branch reads
+		* each device's settings row one at a time, so `config` costs a
+		* per-device round-trip as well as its bytes.
+		*/
+		listAll: require_sleep.method(zod.z.object({
+			addonId: zod.z.string().optional(),
+			/**
+			* `slim` omits `config` (returned `{}`), `metadata` (null) and the
+			* `sourceInfo` derived from config — and skips the per-device settings
+			* read that produces them. Everything identifying a device (id, name,
+			* type, online, features, isCamera, parent/link ids) is unchanged.
+			* Do not use it for dispatch routing, which needs `sourceInfo`.
+			*/
+			projection: zod.z.enum(["full", "slim"]).optional(),
+			/** Return only camera devices. Filtering server-side instead of
+			*  shipping 293 rows to find 12. */
+			isCamera: zod.z.boolean().optional()
+		}), zod.z.array(DeviceInfoSchema)),
 		/** Get a single device by numeric deviceId. */
 		getDevice: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), DeviceInfoSchema.nullable()),
 		/** List children of a parent device (by parent numeric id). */
@@ -20792,6 +20824,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.
@@ -27460,6 +27623,7 @@ var CAPABILITY_NAMES = {
 	consumables: "consumables",
 	contact: "contact",
 	control: "control",
+	coreBlocks: "core-blocks",
 	cover: "cover",
 	customModelRegistry: "custom-model-registry",
 	dataStoreProvider: "data-store-provider",
@@ -27712,6 +27876,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "control",
 		name: "control"
 	},
+	{
+		key: "coreBlocks",
+		name: "core-blocks"
+	},
 	{
 		key: "cover",
 		name: "cover"
@@ -28194,6 +28362,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	consumablesCapability,
 	contactCapability,
 	controlCapability,
+	coreBlocksCapability,
 	coverCapability,
 	customModelRegistryCapability,
 	dataStoreProviderCapability,
@@ -29170,6 +29339,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",
@@ -33479,6 +33696,7 @@ var KNOWN_CAP_NAMES = [
 	"color",
 	"consumables",
 	"control",
+	"core-blocks",
 	"cover",
 	"custom-model-registry",
 	"data-store-provider",
@@ -33643,6 +33861,7 @@ var SYSTEM_CAP_NAMES = [
 	"auth-provider",
 	"backup",
 	"broker",
+	"core-blocks",
 	"custom-model-registry",
 	"data-store-provider",
 	"decoder",
@@ -34440,6 +34659,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;
@@ -35024,6 +35248,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;