@camstack/core 0.1.7 → 0.1.10

package/dist/sql-schema-CKz78rId.d.mts

@@ -0,0 +1,97 @@
+import { IFileStorage, StorageLocationName, IStorageLocation, ICamstackAddon, IConfigurable, AddonManifest, AddonContext, CapabilityProviderMap, ConfigUISchema } from '@camstack/types';
+
+declare class FileSystemStorage implements IFileStorage {
+    private readonly basePath;
+    constructor(basePath: string);
+    readFile(filePath: string): Promise<Buffer>;
+    writeFile(filePath: string, data: Buffer): Promise<void>;
+    deleteFile(filePath: string): Promise<void>;
+    listFiles(prefix?: string): Promise<readonly string[]>;
+    getFileUrl(_path: string): Promise<string>;
+    exists(filePath: string): Promise<boolean>;
+}
+/** @deprecated Use FilesystemStorageProvider + SqliteSettingsBackend instead */
+declare class SqliteStorageProvider {
+    private mainDb;
+    private sharedStructured;
+    private readonly locations;
+    initialize(): Promise<void>;
+    /**
+     * Configure all storage locations.
+     * ONE single SQLite database (camstack.db) is used for ALL structured storage.
+     * File-based locations use the filesystem at their configured path.
+     */
+    configure(config: {
+        locations: Record<string, string>;
+    }): Promise<void>;
+    getLocation(name: StorageLocationName): IStorageLocation;
+    shutdown(): Promise<void>;
+    export(_locationName: StorageLocationName): Promise<Buffer>;
+    import(_locationName: StorageLocationName, _data: Buffer): Promise<void>;
+}
+
+declare class SqliteStorageAddon implements ICamstackAddon, IConfigurable {
+    readonly manifest: AddonManifest;
+    private provider;
+    initialize(context: AddonContext): Promise<void>;
+    shutdown(): Promise<void>;
+    getProvider(): SqliteStorageProvider;
+    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
+    getConfigSchema(): ConfigUISchema;
+    getConfig(): Record<string, unknown>;
+    onConfigChange(_config: Record<string, unknown>): Promise<void>;
+}
+
+/**
+ * Thin wrapper over better-sqlite3 that manages the four settings tables:
+ * system_settings, addon_settings, provider_settings, device_settings.
+ *
+ * All values are stored as JSON text and deserialized on read.
+ */
+declare class SettingsStore {
+    private readonly db;
+    constructor(dbPath: string);
+    getSystem(key: string): unknown;
+    setSystem(key: string, value: unknown): void;
+    getAllSystem(): Record<string, unknown>;
+    getAddon(addonId: string, key: string): unknown;
+    setAddon(addonId: string, key: string, value: unknown): void;
+    getAllAddon(addonId: string): Record<string, unknown>;
+    /** Bulk-replace all keys for an addon (within a transaction). */
+    setAllAddon(addonId: string, config: Record<string, unknown>): void;
+    getProvider(providerId: string, key: string): unknown;
+    setProvider(providerId: string, key: string, value: unknown): void;
+    getAllProvider(providerId: string): Record<string, unknown>;
+    getDevice(deviceId: string, key: string): unknown;
+    setDevice(deviceId: string, key: string, value: unknown): void;
+    getAllDevice(deviceId: string): Record<string, unknown>;
+    /** Close the SQLite connection (call on shutdown). */
+    close(): void;
+    /** Check if system_settings is empty (used for first-boot seeding). */
+    isSystemSettingsEmpty(): boolean;
+    /** Seed system_settings with RUNTIME_DEFAULTS (only on first boot). */
+    seedDefaults(): void;
+    private initTables;
+}
+
+/** Core table DDL statements -- executed on first boot */
+declare const CORE_TABLE_DDL: readonly string[];
+/** Addon table schema declaration */
+interface AddonTableSchema {
+    readonly name: string;
+    readonly columns: ReadonlyArray<{
+        readonly name: string;
+        readonly type: 'TEXT' | 'INTEGER' | 'REAL' | 'JSON';
+        readonly primaryKey?: boolean;
+        readonly notNull?: boolean;
+    }>;
+    readonly indexes?: ReadonlyArray<{
+        readonly name: string;
+        readonly columns: readonly string[];
+        readonly unique?: boolean;
+    }>;
+}
+/** Generate CREATE TABLE DDL from addon schema */
+declare function addonTableToDdl(schema: AddonTableSchema): string[];
+
+export { type AddonTableSchema as A, CORE_TABLE_DDL as C, FileSystemStorage as F, SettingsStore as S, SqliteStorageAddon as a, SqliteStorageProvider as b, addonTableToDdl as c };

package/dist/sql-schema-CKz78rId.d.ts

@@ -0,0 +1,97 @@
+import { IFileStorage, StorageLocationName, IStorageLocation, ICamstackAddon, IConfigurable, AddonManifest, AddonContext, CapabilityProviderMap, ConfigUISchema } from '@camstack/types';
+
+declare class FileSystemStorage implements IFileStorage {
+    private readonly basePath;
+    constructor(basePath: string);
+    readFile(filePath: string): Promise<Buffer>;
+    writeFile(filePath: string, data: Buffer): Promise<void>;
+    deleteFile(filePath: string): Promise<void>;
+    listFiles(prefix?: string): Promise<readonly string[]>;
+    getFileUrl(_path: string): Promise<string>;
+    exists(filePath: string): Promise<boolean>;
+}
+/** @deprecated Use FilesystemStorageProvider + SqliteSettingsBackend instead */
+declare class SqliteStorageProvider {
+    private mainDb;
+    private sharedStructured;
+    private readonly locations;
+    initialize(): Promise<void>;
+    /**
+     * Configure all storage locations.
+     * ONE single SQLite database (camstack.db) is used for ALL structured storage.
+     * File-based locations use the filesystem at their configured path.
+     */
+    configure(config: {
+        locations: Record<string, string>;
+    }): Promise<void>;
+    getLocation(name: StorageLocationName): IStorageLocation;
+    shutdown(): Promise<void>;
+    export(_locationName: StorageLocationName): Promise<Buffer>;
+    import(_locationName: StorageLocationName, _data: Buffer): Promise<void>;
+}
+
+declare class SqliteStorageAddon implements ICamstackAddon, IConfigurable {
+    readonly manifest: AddonManifest;
+    private provider;
+    initialize(context: AddonContext): Promise<void>;
+    shutdown(): Promise<void>;
+    getProvider(): SqliteStorageProvider;
+    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
+    getConfigSchema(): ConfigUISchema;
+    getConfig(): Record<string, unknown>;
+    onConfigChange(_config: Record<string, unknown>): Promise<void>;
+}
+
+/**
+ * Thin wrapper over better-sqlite3 that manages the four settings tables:
+ * system_settings, addon_settings, provider_settings, device_settings.
+ *
+ * All values are stored as JSON text and deserialized on read.
+ */
+declare class SettingsStore {
+    private readonly db;
+    constructor(dbPath: string);
+    getSystem(key: string): unknown;
+    setSystem(key: string, value: unknown): void;
+    getAllSystem(): Record<string, unknown>;
+    getAddon(addonId: string, key: string): unknown;
+    setAddon(addonId: string, key: string, value: unknown): void;
+    getAllAddon(addonId: string): Record<string, unknown>;
+    /** Bulk-replace all keys for an addon (within a transaction). */
+    setAllAddon(addonId: string, config: Record<string, unknown>): void;
+    getProvider(providerId: string, key: string): unknown;
+    setProvider(providerId: string, key: string, value: unknown): void;
+    getAllProvider(providerId: string): Record<string, unknown>;
+    getDevice(deviceId: string, key: string): unknown;
+    setDevice(deviceId: string, key: string, value: unknown): void;
+    getAllDevice(deviceId: string): Record<string, unknown>;
+    /** Close the SQLite connection (call on shutdown). */
+    close(): void;
+    /** Check if system_settings is empty (used for first-boot seeding). */
+    isSystemSettingsEmpty(): boolean;
+    /** Seed system_settings with RUNTIME_DEFAULTS (only on first boot). */
+    seedDefaults(): void;
+    private initTables;
+}
+
+/** Core table DDL statements -- executed on first boot */
+declare const CORE_TABLE_DDL: readonly string[];
+/** Addon table schema declaration */
+interface AddonTableSchema {
+    readonly name: string;
+    readonly columns: ReadonlyArray<{
+        readonly name: string;
+        readonly type: 'TEXT' | 'INTEGER' | 'REAL' | 'JSON';
+        readonly primaryKey?: boolean;
+        readonly notNull?: boolean;
+    }>;
+    readonly indexes?: ReadonlyArray<{
+        readonly name: string;
+        readonly columns: readonly string[];
+        readonly unique?: boolean;
+    }>;
+}
+/** Generate CREATE TABLE DDL from addon schema */
+declare function addonTableToDdl(schema: AddonTableSchema): string[];
+
+export { type AddonTableSchema as A, CORE_TABLE_DDL as C, FileSystemStorage as F, SettingsStore as S, SqliteStorageAddon as a, SqliteStorageProvider as b, addonTableToDdl as c };

package/dist/sqlite-settings.addon-DigoKwpZ.d.mts

@@ -0,0 +1,70 @@
+import { ISettingsBackend, SettingsCollection, QueryFilter, SettingsRecord, ICamstackAddon, IConfigurable, AddonManifest, AddonContext, CapabilityProviderMap, ConfigUISchema } from '@camstack/types';
+
+/**
+ * SQLite implementation of ISettingsBackend.
+ *
+ * One table per collection, auto-created on first access.
+ * All data stored as JSON in a TEXT column.
+ * WAL mode for concurrent reads.
+ */
+declare class SqliteSettingsBackend implements ISettingsBackend {
+    private readonly dbPath;
+    private db;
+    private readonly ensuredTables;
+    private readonly runtimeDefaults;
+    constructor(dbPath: string, runtimeDefaults?: Record<string, unknown>);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    get(collection: SettingsCollection, key: string): Promise<unknown>;
+    set(collection: SettingsCollection, key: string, value: unknown): Promise<void>;
+    query(collection: SettingsCollection, filter?: QueryFilter): Promise<readonly SettingsRecord[]>;
+    insert(collection: SettingsCollection, record: SettingsRecord): Promise<void>;
+    update(collection: SettingsCollection, id: string, data: Record<string, unknown>): Promise<void>;
+    delete(collection: SettingsCollection, key: string): Promise<void>;
+    count(collection: SettingsCollection, filter?: QueryFilter): Promise<number>;
+    isEmpty(collection: SettingsCollection): Promise<boolean>;
+    /** Get a system setting by dot-notation key */
+    getSystem(key: string): unknown;
+    /** Set a system setting */
+    setSystem(key: string, value: unknown): void;
+    /** Get all system settings as flat key-value */
+    getAllSystem(): Record<string, unknown>;
+    /** Get all settings for an addon */
+    getAllAddon(addonId: string): Record<string, unknown>;
+    /** Bulk-set all settings for an addon */
+    setAllAddon(addonId: string, config: Record<string, unknown>): void;
+    /** Get all settings for a provider */
+    getAllProvider(providerId: string): Record<string, unknown>;
+    /** Set a provider setting */
+    setProvider(providerId: string, key: string, value: unknown): void;
+    /** Get all settings for a device */
+    getAllDevice(deviceId: string): Record<string, unknown>;
+    /** Set a device setting */
+    setDevice(deviceId: string, key: string, value: unknown): void;
+    /** Seed system-settings with runtime defaults (first boot) */
+    private seedDefaults;
+    private getDb;
+    private ensureTable;
+    private getAllScoped;
+    private setScopedKey;
+}
+
+/**
+ * SQLite Settings addon — provides persistent settings storage.
+ * Capability: 'settings-store' (singleton)
+ *
+ * Depends on 'storage' capability for resolving the DB file path.
+ */
+declare class SqliteSettingsAddon implements ICamstackAddon, IConfigurable {
+    readonly manifest: AddonManifest;
+    private backend;
+    initialize(context: AddonContext): Promise<void>;
+    shutdown(): Promise<void>;
+    getBackend(): SqliteSettingsBackend | null;
+    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
+    getConfigSchema(): ConfigUISchema;
+    getConfig(): Record<string, unknown>;
+    onConfigChange(_config: Record<string, unknown>): Promise<void>;
+}
+
+export { SqliteSettingsAddon as S, SqliteSettingsBackend as a };

package/dist/sqlite-settings.addon-DigoKwpZ.d.ts

@@ -0,0 +1,70 @@
+import { ISettingsBackend, SettingsCollection, QueryFilter, SettingsRecord, ICamstackAddon, IConfigurable, AddonManifest, AddonContext, CapabilityProviderMap, ConfigUISchema } from '@camstack/types';
+
+/**
+ * SQLite implementation of ISettingsBackend.
+ *
+ * One table per collection, auto-created on first access.
+ * All data stored as JSON in a TEXT column.
+ * WAL mode for concurrent reads.
+ */
+declare class SqliteSettingsBackend implements ISettingsBackend {
+    private readonly dbPath;
+    private db;
+    private readonly ensuredTables;
+    private readonly runtimeDefaults;
+    constructor(dbPath: string, runtimeDefaults?: Record<string, unknown>);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    get(collection: SettingsCollection, key: string): Promise<unknown>;
+    set(collection: SettingsCollection, key: string, value: unknown): Promise<void>;
+    query(collection: SettingsCollection, filter?: QueryFilter): Promise<readonly SettingsRecord[]>;
+    insert(collection: SettingsCollection, record: SettingsRecord): Promise<void>;
+    update(collection: SettingsCollection, id: string, data: Record<string, unknown>): Promise<void>;
+    delete(collection: SettingsCollection, key: string): Promise<void>;
+    count(collection: SettingsCollection, filter?: QueryFilter): Promise<number>;
+    isEmpty(collection: SettingsCollection): Promise<boolean>;
+    /** Get a system setting by dot-notation key */
+    getSystem(key: string): unknown;
+    /** Set a system setting */
+    setSystem(key: string, value: unknown): void;
+    /** Get all system settings as flat key-value */
+    getAllSystem(): Record<string, unknown>;
+    /** Get all settings for an addon */
+    getAllAddon(addonId: string): Record<string, unknown>;
+    /** Bulk-set all settings for an addon */
+    setAllAddon(addonId: string, config: Record<string, unknown>): void;
+    /** Get all settings for a provider */
+    getAllProvider(providerId: string): Record<string, unknown>;
+    /** Set a provider setting */
+    setProvider(providerId: string, key: string, value: unknown): void;
+    /** Get all settings for a device */
+    getAllDevice(deviceId: string): Record<string, unknown>;
+    /** Set a device setting */
+    setDevice(deviceId: string, key: string, value: unknown): void;
+    /** Seed system-settings with runtime defaults (first boot) */
+    private seedDefaults;
+    private getDb;
+    private ensureTable;
+    private getAllScoped;
+    private setScopedKey;
+}
+
+/**
+ * SQLite Settings addon — provides persistent settings storage.
+ * Capability: 'settings-store' (singleton)
+ *
+ * Depends on 'storage' capability for resolving the DB file path.
+ */
+declare class SqliteSettingsAddon implements ICamstackAddon, IConfigurable {
+    readonly manifest: AddonManifest;
+    private backend;
+    initialize(context: AddonContext): Promise<void>;
+    shutdown(): Promise<void>;
+    getBackend(): SqliteSettingsBackend | null;
+    getCapabilityProvider<K extends keyof CapabilityProviderMap>(name: K): CapabilityProviderMap[K] | null;
+    getConfigSchema(): ConfigUISchema;
+    getConfig(): Record<string, unknown>;
+    onConfigChange(_config: Record<string, unknown>): Promise<void>;
+}
+
+export { SqliteSettingsAddon as S, SqliteSettingsBackend as a };

package/dist/storage-location-manager-KKDQNAKA.mjs

@@ -0,0 +1,7 @@
+import {
+  StorageLocationManager
+} from "./chunk-2F3XZYRW.mjs";
+export {
+  StorageLocationManager
+};
+//# sourceMappingURL=storage-location-manager-KKDQNAKA.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/core",
-  "version": "0.1.7",
+  "version": "0.1.10",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",

package/dist/chunk-4JEXNFZZ.mjs

@@ -1,57 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __glob = (map) => (path) => {
-  var fn = map[path];
-  if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path);
-};
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-export {
-  __require,
-  __glob,
-  __esm,
-  __commonJS,
-  __export,
-  __reExport,
-  __toESM,
-  __toCommonJS
-};
-//# sourceMappingURL=chunk-4JEXNFZZ.mjs.map

package/dist/chunk-4YD6WMO6.mjs

@@ -1,207 +0,0 @@
-import {
-  __esm,
-  __export
-} from "./chunk-4JEXNFZZ.mjs";
-
-// src/builtins/sqlite-storage/filesystem-storage-provider.ts
-var filesystem_storage_provider_exports = {};
-__export(filesystem_storage_provider_exports, {
-  FilesystemStorageProvider: () => FilesystemStorageProvider,
-  default: () => filesystem_storage_provider_default
-});
-import * as fs from "fs";
-import * as path from "path";
-var STORAGE_LOCATION_TYPES, DEFAULT_LOCATION_SUBDIRS, FilesystemStorageProvider, filesystem_storage_provider_default;
-var init_filesystem_storage_provider = __esm({
-  "src/builtins/sqlite-storage/filesystem-storage-provider.ts"() {
-    "use strict";
-    STORAGE_LOCATION_TYPES = [
-      "recordings-high",
-      "recordings-low",
-      "recordings-clips",
-      "event-images",
-      "models",
-      "addons-data",
-      "cache",
-      "logs"
-    ];
-    DEFAULT_LOCATION_SUBDIRS = {
-      "recordings-high": "recordings-high",
-      "recordings-low": "recordings-low",
-      "recordings-clips": "recordings-clips",
-      "event-images": "event-images",
-      "models": "models",
-      "addons-data": "addons-data",
-      "cache": "/tmp/camstack-cache",
-      "logs": "logs"
-    };
-    FilesystemStorageProvider = class {
-      id = "local";
-      name = "Local Filesystem";
-      supportedLocations = [...STORAGE_LOCATION_TYPES];
-      rootPath;
-      locationPaths;
-      constructor(rootPath, overrides) {
-        this.rootPath = path.resolve(rootPath);
-        this.locationPaths = /* @__PURE__ */ new Map();
-        for (const loc of STORAGE_LOCATION_TYPES) {
-          const override = overrides?.[loc];
-          if (override) {
-            this.locationPaths.set(loc, path.resolve(override));
-          } else {
-            const subdir = DEFAULT_LOCATION_SUBDIRS[loc];
-            this.locationPaths.set(
-              loc,
-              path.isAbsolute(subdir) ? subdir : path.join(this.rootPath, subdir)
-            );
-          }
-        }
-      }
-      resolve(location, relativePath) {
-        const base = this.locationPaths.get(location);
-        if (!base) throw new Error(`Unknown storage location: ${location}`);
-        return path.join(base, relativePath);
-      }
-      async write(location, relativePath, data) {
-        const filePath = this.resolve(location, relativePath);
-        await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
-        if (Buffer.isBuffer(data)) {
-          await fs.promises.writeFile(filePath, data);
-        } else {
-          const writeStream = fs.createWriteStream(filePath);
-          await new Promise((resolve2, reject) => {
-            data.pipe(writeStream);
-            writeStream.on("finish", resolve2);
-            writeStream.on("error", reject);
-          });
-        }
-      }
-      async read(location, relativePath) {
-        return fs.promises.readFile(this.resolve(location, relativePath));
-      }
-      async exists(location, relativePath) {
-        try {
-          await fs.promises.access(this.resolve(location, relativePath));
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      async list(location, prefix) {
-        const base = this.locationPaths.get(location);
-        if (!base) return [];
-        const dir = prefix ? path.join(base, prefix) : base;
-        try {
-          const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-          return entries.map((e) => prefix ? `${prefix}/${e.name}` : e.name);
-        } catch {
-          return [];
-        }
-      }
-      async delete(location, relativePath) {
-        const filePath = this.resolve(location, relativePath);
-        await fs.promises.rm(filePath, { force: true });
-      }
-      async getAvailableSpace(location) {
-        const base = this.locationPaths.get(location);
-        if (!base) return null;
-        try {
-          const stats = await fs.promises.statfs(base);
-          return stats.bavail * stats.bsize;
-        } catch {
-          return null;
-        }
-      }
-      async initialize() {
-        for (const [, dirPath] of this.locationPaths) {
-          await fs.promises.mkdir(dirPath, { recursive: true });
-        }
-      }
-      async shutdown() {
-      }
-      /** Get the resolved path for a location type */
-      getLocationPath(location) {
-        const p = this.locationPaths.get(location);
-        if (!p) throw new Error(`Unknown storage location: ${location}`);
-        return p;
-      }
-      /** Get the root path */
-      getRootPath() {
-        return this.rootPath;
-      }
-    };
-    filesystem_storage_provider_default = FilesystemStorageProvider;
-  }
-});
-
-// src/builtins/sqlite-storage/filesystem-storage.addon.ts
-var filesystem_storage_addon_exports = {};
-__export(filesystem_storage_addon_exports, {
-  FilesystemStorageAddon: () => FilesystemStorageAddon,
-  default: () => filesystem_storage_addon_default
-});
-var FilesystemStorageAddon, filesystem_storage_addon_default;
-var init_filesystem_storage_addon = __esm({
-  "src/builtins/sqlite-storage/filesystem-storage.addon.ts"() {
-    init_filesystem_storage_provider();
-    FilesystemStorageAddon = class {
-      manifest = {
-        id: "filesystem-storage",
-        name: "Local Filesystem Storage",
-        version: "1.0.0",
-        capabilities: [{ name: "storage", mode: "collection" }]
-      };
-      provider = null;
-      currentConfig = {
-        rootPath: "camstack-data"
-      };
-      async initialize(context) {
-        const rootPath = context.addonConfig.rootPath ?? this.currentConfig.rootPath;
-        this.currentConfig.rootPath = rootPath;
-        const overrides = {};
-        for (const key of Object.keys(context.addonConfig)) {
-          if (key.startsWith("override.")) {
-            const loc = key.slice("override.".length);
-            overrides[loc] = context.addonConfig[key];
-          }
-        }
-        this.provider = new FilesystemStorageProvider(rootPath, overrides);
-        await this.provider.initialize();
-        context.logger.info(`Filesystem storage initialized at ${this.provider.getRootPath()}`);
-      }
-      async shutdown() {
-        await this.provider?.shutdown();
-      }
-      getCapabilityProvider(name) {
-        if (name === "storage" && this.provider) {
-          return this.provider;
-        }
-        return null;
-      }
-      getProvider() {
-        return this.provider;
-      }
-      getConfigSchema() {
-        return { sections: [] };
-      }
-      getConfig() {
-        return { ...this.currentConfig };
-      }
-      async onConfigChange(config) {
-        this.currentConfig.rootPath = config.rootPath ?? this.currentConfig.rootPath;
-      }
-    };
-    filesystem_storage_addon_default = FilesystemStorageAddon;
-  }
-});
-
-export {
-  FilesystemStorageProvider,
-  filesystem_storage_provider_exports,
-  init_filesystem_storage_provider,
-  FilesystemStorageAddon,
-  filesystem_storage_addon_default,
-  filesystem_storage_addon_exports,
-  init_filesystem_storage_addon
-};
-//# sourceMappingURL=chunk-4YD6WMO6.mjs.map