@camstack/types 0.1.30 → 0.1.32

package/dist/capabilities/network-access.cap.d.ts

@@ -22,11 +22,33 @@ declare const NetworkAccessStatusSchema: z.ZodObject<{
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * Optional, richer endpoint shape returned by providers that expose
+ * MORE than one ingress concurrently (Tailscale Ingress with mixed
+ * serve+funnel rules, future ngrok multi-tunnel, …). Each entry carries
+ * the originating provider config (mode + sourcePort) so the
+ * orchestrator UI can label rows distinctly. Providers that expose only
+ * one endpoint just omit `listEndpoints` from their provider impl.
+ */
+declare const NetworkEndpointEntrySchema: z.ZodObject<{
+    url: z.ZodString;
+    hostname: z.ZodString;
+    port: z.ZodNumber;
+    protocol: z.ZodEnum<{
+        http: "http";
+        https: "https";
+    }>;
+    id: z.ZodString;
+    label: z.ZodString;
+    mode: z.ZodOptional<z.ZodString>;
+    sourcePort: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export declare const networkAccessCapability: {
     readonly name: "network-access";
     readonly scope: "system";
     readonly mode: "collection";
     readonly internal: true;
+    readonly providerKind: "ingress";
     readonly methods: {
         readonly start: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             url: z.ZodString;
@@ -60,8 +82,26 @@ export declare const networkAccessCapability: {
             }, z.core.$strip>>;
             error: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Enumerate every active ingress entry. Default implementation (when
+         * the provider omits this method) is derived from `getEndpoint()` —
+         * see the remote-access orchestrator for the fallback path.
+         */
+        readonly listEndpoints: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            hostname: z.ZodString;
+            port: z.ZodNumber;
+            protocol: z.ZodEnum<{
+                http: "http";
+                https: "https";
+            }>;
+            id: z.ZodString;
+            label: z.ZodString;
+            mode: z.ZodOptional<z.ZodString>;
+            sourcePort: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
     };
 };
 export type INetworkAccessProvider = InferProvider<typeof networkAccessCapability>;
-export { NetworkEndpointSchema, NetworkAccessStatusSchema };
+export { NetworkEndpointSchema, NetworkAccessStatusSchema, NetworkEndpointEntrySchema };
 //# sourceMappingURL=network-access.cap.d.ts.map

package/dist/capabilities/network-access.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-access.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/network-access.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,qBAAqB;;;;;;;;iBAKzB,CAAA;AAEF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;iBAI7B,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWK,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,CAAA"}
+{"version":3,"file":"network-access.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/network-access.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,qBAAqB;;;;;;;;iBAKzB,CAAA;AAEF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;iBAI7B,CAAA;AAEF;;;;;;;GAOG;AACH,QAAA,MAAM,0BAA0B;;;;;;;;;;;;iBAY9B,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAWhC;;;;WAIG;;;;;;;;;;;;;;;CAGkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,CAAA"}

package/dist/capabilities/platform-probe.cap.d.ts

@@ -1,11 +1,118 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
+declare const HardwareEncoderIdSchema: z.ZodEnum<{
+    h264_videotoolbox: "h264_videotoolbox";
+    hevc_videotoolbox: "hevc_videotoolbox";
+    h264_vaapi: "h264_vaapi";
+    hevc_vaapi: "hevc_vaapi";
+    h264_nvenc: "h264_nvenc";
+    hevc_nvenc: "hevc_nvenc";
+    h264_qsv: "h264_qsv";
+    hevc_qsv: "hevc_qsv";
+    h264_amf: "h264_amf";
+    hevc_amf: "hevc_amf";
+    libx264: "libx264";
+    libx265: "libx265";
+}>;
+export type HardwareEncoderId = z.infer<typeof HardwareEncoderIdSchema>;
+declare const HardwareEncoderProbeSchema: z.ZodObject<{
+    encoder: z.ZodEnum<{
+        h264_videotoolbox: "h264_videotoolbox";
+        hevc_videotoolbox: "hevc_videotoolbox";
+        h264_vaapi: "h264_vaapi";
+        hevc_vaapi: "hevc_vaapi";
+        h264_nvenc: "h264_nvenc";
+        hevc_nvenc: "hevc_nvenc";
+        h264_qsv: "h264_qsv";
+        hevc_qsv: "hevc_qsv";
+        h264_amf: "h264_amf";
+        hevc_amf: "hevc_amf";
+        libx264: "libx264";
+        libx265: "libx265";
+    }>;
+    codec: z.ZodEnum<{
+        H264: "H264";
+        H265: "H265";
+    }>;
+    family: z.ZodEnum<{
+        videotoolbox: "videotoolbox";
+        vaapi: "vaapi";
+        qsv: "qsv";
+        amf: "amf";
+        nvenc: "nvenc";
+        software: "software";
+    }>;
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HardwareEncoderProbe = z.infer<typeof HardwareEncoderProbeSchema>;
+declare const HardwareEncodersSchema: z.ZodObject<{
+    encoders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        encoder: z.ZodEnum<{
+            h264_videotoolbox: "h264_videotoolbox";
+            hevc_videotoolbox: "hevc_videotoolbox";
+            h264_vaapi: "h264_vaapi";
+            hevc_vaapi: "hevc_vaapi";
+            h264_nvenc: "h264_nvenc";
+            hevc_nvenc: "hevc_nvenc";
+            h264_qsv: "h264_qsv";
+            hevc_qsv: "hevc_qsv";
+            h264_amf: "h264_amf";
+            hevc_amf: "hevc_amf";
+            libx264: "libx264";
+            libx265: "libx265";
+        }>;
+        codec: z.ZodEnum<{
+            H264: "H264";
+            H265: "H265";
+        }>;
+        family: z.ZodEnum<{
+            videotoolbox: "videotoolbox";
+            vaapi: "vaapi";
+            qsv: "qsv";
+            amf: "amf";
+            nvenc: "nvenc";
+            software: "software";
+        }>;
+        available: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    defaultH264: z.ZodEnum<{
+        h264_videotoolbox: "h264_videotoolbox";
+        hevc_videotoolbox: "hevc_videotoolbox";
+        h264_vaapi: "h264_vaapi";
+        hevc_vaapi: "hevc_vaapi";
+        h264_nvenc: "h264_nvenc";
+        hevc_nvenc: "hevc_nvenc";
+        h264_qsv: "h264_qsv";
+        hevc_qsv: "hevc_qsv";
+        h264_amf: "h264_amf";
+        hevc_amf: "hevc_amf";
+        libx264: "libx264";
+        libx265: "libx265";
+    }>;
+    defaultH265: z.ZodEnum<{
+        h264_videotoolbox: "h264_videotoolbox";
+        hevc_videotoolbox: "hevc_videotoolbox";
+        h264_vaapi: "h264_vaapi";
+        hevc_vaapi: "hevc_vaapi";
+        h264_nvenc: "h264_nvenc";
+        hevc_nvenc: "hevc_nvenc";
+        h264_qsv: "h264_qsv";
+        hevc_qsv: "hevc_qsv";
+        h264_amf: "h264_amf";
+        hevc_amf: "hevc_amf";
+        libx264: "libx264";
+        libx265: "libx265";
+    }>;
+    probedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type HardwareEncoders = z.infer<typeof HardwareEncodersSchema>;
 export declare const platformProbeCapability: {
     readonly name: "platform-probe";
     readonly scope: "system";
     readonly mode: "singleton";
     readonly methods: {
-        /** Return cached hardware + scored backends for this node. */
         readonly getCapabilities: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             hardware: z.ZodObject<{
                 platform: z.ZodEnum<{
@@ -70,7 +177,6 @@ export declare const platformProbeCapability: {
             }, z.core.$strip>;
             pythonPath: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
-        /** Convenience getter — hardware only. */
         readonly getHardware: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             platform: z.ZodEnum<{
                 darwin: "darwin";
@@ -102,12 +208,6 @@ export declare const platformProbeCapability: {
                 }>;
             }, z.core.$strip>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
-        /**
-         * Resolve the best (model, runtime, backend, format) for a given list
-         * of requirements, using this node's scored backends as the candidate
-         * pool. Always returns a config — falls back to CPU when no preferred
-         * backend matches.
-         */
         readonly resolveInferenceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             requirements: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 modelId: z.ZodString;
@@ -132,13 +232,6 @@ export declare const platformProbeCapability: {
             }>;
             reason: z.ZodString;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
-        /**
-         * Resolve the ordered HW acceleration backend list for this node.
-         * Pass `prefer` to hint a specific backend; pass `null` or omit
-         * for auto-detection. Replaces the legacy `$hwaccel.resolve`
-         * Moleculer action — cap routing handles per-node dispatch via
-         * `nodeId`.
-         */
         readonly resolveHwAccel: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             prefer: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                 coreml: "coreml";
@@ -162,7 +255,133 @@ export declare const platformProbeCapability: {
         }, z.core.$strip>, z.ZodObject<{
             preferred: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Hardware-encoder probe — see Task #185. Cached after first call.
+         */
+        readonly getHardwareEncoders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            encoders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                encoder: z.ZodEnum<{
+                    h264_videotoolbox: "h264_videotoolbox";
+                    hevc_videotoolbox: "hevc_videotoolbox";
+                    h264_vaapi: "h264_vaapi";
+                    hevc_vaapi: "hevc_vaapi";
+                    h264_nvenc: "h264_nvenc";
+                    hevc_nvenc: "hevc_nvenc";
+                    h264_qsv: "h264_qsv";
+                    hevc_qsv: "hevc_qsv";
+                    h264_amf: "h264_amf";
+                    hevc_amf: "hevc_amf";
+                    libx264: "libx264";
+                    libx265: "libx265";
+                }>;
+                codec: z.ZodEnum<{
+                    H264: "H264";
+                    H265: "H265";
+                }>;
+                family: z.ZodEnum<{
+                    videotoolbox: "videotoolbox";
+                    vaapi: "vaapi";
+                    qsv: "qsv";
+                    amf: "amf";
+                    nvenc: "nvenc";
+                    software: "software";
+                }>;
+                available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            defaultH264: z.ZodEnum<{
+                h264_videotoolbox: "h264_videotoolbox";
+                hevc_videotoolbox: "hevc_videotoolbox";
+                h264_vaapi: "h264_vaapi";
+                hevc_vaapi: "hevc_vaapi";
+                h264_nvenc: "h264_nvenc";
+                hevc_nvenc: "hevc_nvenc";
+                h264_qsv: "h264_qsv";
+                hevc_qsv: "hevc_qsv";
+                h264_amf: "h264_amf";
+                hevc_amf: "hevc_amf";
+                libx264: "libx264";
+                libx265: "libx265";
+            }>;
+            defaultH265: z.ZodEnum<{
+                h264_videotoolbox: "h264_videotoolbox";
+                hevc_videotoolbox: "hevc_videotoolbox";
+                h264_vaapi: "h264_vaapi";
+                hevc_vaapi: "hevc_vaapi";
+                h264_nvenc: "h264_nvenc";
+                hevc_nvenc: "hevc_nvenc";
+                h264_qsv: "h264_qsv";
+                hevc_qsv: "hevc_qsv";
+                h264_amf: "h264_amf";
+                hevc_amf: "hevc_amf";
+                libx264: "libx264";
+                libx265: "libx265";
+            }>;
+            probedAt: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly refreshHardwareEncoders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            encoders: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                encoder: z.ZodEnum<{
+                    h264_videotoolbox: "h264_videotoolbox";
+                    hevc_videotoolbox: "hevc_videotoolbox";
+                    h264_vaapi: "h264_vaapi";
+                    hevc_vaapi: "hevc_vaapi";
+                    h264_nvenc: "h264_nvenc";
+                    hevc_nvenc: "hevc_nvenc";
+                    h264_qsv: "h264_qsv";
+                    hevc_qsv: "hevc_qsv";
+                    h264_amf: "h264_amf";
+                    hevc_amf: "hevc_amf";
+                    libx264: "libx264";
+                    libx265: "libx265";
+                }>;
+                codec: z.ZodEnum<{
+                    H264: "H264";
+                    H265: "H265";
+                }>;
+                family: z.ZodEnum<{
+                    videotoolbox: "videotoolbox";
+                    vaapi: "vaapi";
+                    qsv: "qsv";
+                    amf: "amf";
+                    nvenc: "nvenc";
+                    software: "software";
+                }>;
+                available: z.ZodBoolean;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            defaultH264: z.ZodEnum<{
+                h264_videotoolbox: "h264_videotoolbox";
+                hevc_videotoolbox: "hevc_videotoolbox";
+                h264_vaapi: "h264_vaapi";
+                hevc_vaapi: "hevc_vaapi";
+                h264_nvenc: "h264_nvenc";
+                hevc_nvenc: "hevc_nvenc";
+                h264_qsv: "h264_qsv";
+                hevc_qsv: "hevc_qsv";
+                h264_amf: "h264_amf";
+                hevc_amf: "hevc_amf";
+                libx264: "libx264";
+                libx265: "libx265";
+            }>;
+            defaultH265: z.ZodEnum<{
+                h264_videotoolbox: "h264_videotoolbox";
+                hevc_videotoolbox: "hevc_videotoolbox";
+                h264_vaapi: "h264_vaapi";
+                hevc_vaapi: "hevc_vaapi";
+                h264_nvenc: "h264_nvenc";
+                hevc_nvenc: "hevc_nvenc";
+                h264_qsv: "h264_qsv";
+                hevc_qsv: "hevc_qsv";
+                h264_amf: "h264_amf";
+                hevc_amf: "hevc_amf";
+                libx264: "libx264";
+                libx265: "libx265";
+            }>;
+            probedAt: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
     };
 };
 export type IPlatformProbeProvider = InferProvider<typeof platformProbeCapability>;
+export {};
 //# sourceMappingURL=platform-probe.cap.d.ts.map

package/dist/capabilities/platform-probe.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform-probe.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/platform-probe.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAuFlG,eAAO,MAAM,uBAAuB;;;;;QAKhC,8DAA8D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAK9D,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAK1C;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;QAOH;;;;;;WAMG;;;;;;;;;;;;;;;;;;;;;;;;;CASkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}
+{"version":3,"file":"platform-probe.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/platform-probe.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAgBlG,QAAA,MAAM,uBAAuB;;;;;;;;;;;;;EAa3B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,QAAA,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM9B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK1B,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AA0DrE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAehC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}

package/dist/capabilities/settings-store.cap.d.ts

@@ -24,8 +24,12 @@ declare const SettingsRecordSchema: z.ZodObject<{
 }, z.core.$strip>;
 /**
  * Column declaration for a structured (SQL-backed) collection.
- * SQLite types: TEXT, INTEGER, REAL, JSON (JSON is a compatibility type —
- * SQLite stores it as TEXT, backend handles serialization).
+ *
+ * Logical types — the backend translates each to the matching SQLite
+ * storage class and handles per-type marshaling:
+ *   - `TEXT` / `INTEGER` / `REAL` — native SQLite types, pass-through
+ *   - `JSON`    — TEXT under the hood; serialised on write, parsed on read
+ *   - `BOOLEAN` — INTEGER 0/1 under the hood; coerced both directions
  */
 declare const CollectionColumnSchema: z.ZodObject<{
     name: z.ZodString;
@@ -34,6 +38,7 @@ declare const CollectionColumnSchema: z.ZodObject<{
         INTEGER: "INTEGER";
         REAL: "REAL";
         JSON: "JSON";
+        BOOLEAN: "BOOLEAN";
     }>;
     primaryKey: z.ZodOptional<z.ZodBoolean>;
     notNull: z.ZodOptional<z.ZodBoolean>;
@@ -172,6 +177,7 @@ export declare const settingsStoreCapability: {
                     INTEGER: "INTEGER";
                     REAL: "REAL";
                     JSON: "JSON";
+                    BOOLEAN: "BOOLEAN";
                 }>;
                 primaryKey: z.ZodOptional<z.ZodBoolean>;
                 notNull: z.ZodOptional<z.ZodBoolean>;

package/dist/capabilities/settings-store.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settings-store.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/settings-store.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;iBAUrB,CAAA;AAEF,8CAA8C;AAC9C,QAAA,MAAM,oBAAoB;;;iBAGxB,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;;QAKhC,mDAAmD;;;;;;QAMnD,mDAAmD;;;;;;;QAOnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;QAMnD,2BAA2B;;;;;;;;;QAO3B,uCAAuC;;;;;;;QAOvC,iCAAiC;;;;;;QAOjC,0DAA0D;;;;;;;;;;;;;;;;;;;QAM1D,sCAAsC;;;;;QAMtC;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;AAE/F,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAA;AAEjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"settings-store.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/settings-store.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;iBAUrB,CAAA;AAEF,8CAA8C;AAC9C,QAAA,MAAM,oBAAoB;;;iBAGxB,CAAA;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;;QAKhC,mDAAmD;;;;;;QAMnD,mDAAmD;;;;;;;QAOnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;QAMnD,2BAA2B;;;;;;;;;QAO3B,uCAAuC;;;;;;;QAOvC,iCAAiC;;;;;;QAOjC,0DAA0D;;;;;;;;;;;;;;;;;;;QAM1D,sCAAsC;;;;;QAMtC;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;AAE/F,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAA;AAEjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

package/dist/capabilities/smtp-provider.cap.d.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const SendEmailInputSchema: z.ZodObject<{
+    to: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>;
+    cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+    bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+    from: z.ZodOptional<z.ZodString>;
+    replyTo: z.ZodOptional<z.ZodString>;
+    subject: z.ZodString;
+    text: z.ZodString;
+    html: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const SendEmailResultSchema: z.ZodObject<{
+    messageId: z.ZodString;
+    accepted: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
+    rejected: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
+}, z.core.$strip>;
+declare const SmtpStatusSchema: z.ZodObject<{
+    ready: z.ZodBoolean;
+    host: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+    lastVerifiedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const smtpProviderCapability: {
+    readonly name: "smtp-provider";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly providerKind: "email";
+    readonly methods: {
+        readonly sendEmail: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            to: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodEmail>]>;
+            cc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            bcc: z.ZodOptional<z.ZodArray<z.ZodEmail>>;
+            from: z.ZodOptional<z.ZodString>;
+            replyTo: z.ZodOptional<z.ZodString>;
+            subject: z.ZodString;
+            text: z.ZodString;
+            html: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            messageId: z.ZodString;
+            accepted: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
+            rejected: z.ZodDefault<z.ZodArray<z.ZodEmail>>;
+        }, z.core.$strip>, "mutation">;
+        /** Round-trip ping against the SMTP relay (EHLO + AUTH if configured).
+         *  Used by the operator's "Test connection" button. */
+        readonly verify: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            ready: z.ZodBoolean;
+            host: z.ZodString;
+            error: z.ZodOptional<z.ZodString>;
+            lastVerifiedAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, "mutation">;
+        readonly getStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            ready: z.ZodBoolean;
+            host: z.ZodString;
+            error: z.ZodOptional<z.ZodString>;
+            lastVerifiedAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type ISmtpProvider = InferProvider<typeof smtpProviderCapability>;
+export { SendEmailInputSchema, SendEmailResultSchema, SmtpStatusSchema };
+//# sourceMappingURL=smtp-provider.cap.d.ts.map

package/dist/capabilities/smtp-provider.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smtp-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/smtp-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAiBlG,QAAA,MAAM,oBAAoB;;;;;;;;;iBAgBxB,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF,QAAA,MAAM,gBAAgB;;;;;iBASpB,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;QAY/B;+DACuD;;;;;;;;;;;;;;CAYlB,CAAA;AAEzC,MAAM,MAAM,aAAa,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACxE,OAAO,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/capabilities/sso-bridge.cap.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `sso-bridge` — internal hub-only cap that lets SSO-style auth
+ * providers (OIDC, SAML, magic-link, …) mint an HMAC-signed token
+ * carrying the post-callback claims before redirecting back to
+ * `/api/auth/sso/finish`.
+ *
+ * Without this, any client could craft a `?isAdmin=1` link to
+ * `/sso/finish` and become admin. With it, the endpoint accepts ONLY
+ * the signed token and rejects everything else.
+ *
+ * Backed by `AuthManager.{signSsoBridgeToken,verifySsoBridgeToken}` —
+ * see `packages/core/src/auth/auth-manager.ts`. The provider is
+ * registered at hub boot in `server/backend/src/main.ts`.
+ */
+declare const SsoBridgeClaimsSchema: z.ZodObject<{
+    userId: z.ZodString;
+    username: z.ZodString;
+    isAdmin: z.ZodBoolean;
+    provider: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    hubUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ssoBridgeCapability: {
+    readonly name: "sso-bridge";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly internal: true;
+    readonly methods: {
+        readonly signBridgeToken: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            claims: z.ZodObject<{
+                userId: z.ZodString;
+                username: z.ZodString;
+                isAdmin: z.ZodBoolean;
+                provider: z.ZodString;
+                email: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodOptional<z.ZodString>;
+                hubUrl: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            ttlSec: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            token: z.ZodString;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly verifyBridgeToken: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            token: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            username: z.ZodString;
+            isAdmin: z.ZodBoolean;
+            provider: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            hubUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type ISsoBridgeProvider = InferProvider<typeof ssoBridgeCapability>;
+export { SsoBridgeClaimsSchema };
+//# sourceMappingURL=sso-bridge.cap.d.ts.map

package/dist/capabilities/sso-bridge.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sso-bridge.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/sso-bridge.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;iBAgBzB,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBS,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC1E,OAAO,EAAE,qBAAqB,EAAE,CAAA"}