@makaio/framework 1.0.0-dev-1781022866275 → 1.0.0-dev-1781023871421

package/dist/storage/drizzle/index.d.mts

@@ -0,0 +1,137 @@
+import { t as MakaioDatabase } from "../../types-dyP-bXXE.mjs";
+import { IMakaioBus } from "@makaio/framework/bus";
+import { ExtensionContext } from "@makaio/framework/contracts";
+import { Table } from "drizzle-orm";
+import { StorageNamespace, StorageNamespaceConfig, StorageNamespaceExtensions, createStorageNamespace } from "@makaio/framework/storage";
+
+//#region storage/drizzle/src/transaction.d.ts
+type LibSQLTransactionExecutor = MakaioDatabase['transaction'];
+/**
+ * Transaction callback that receives Drizzle's transaction context.
+ *
+ * Typed against the libsql async transaction context, which is the widest
+ * compatible contract.  Callbacks written against this type work on both the
+ * libsql (Node.js) and bun-sqlite (Bun) drivers because `await syncValue` is
+ * a JavaScript no-op.
+ * @typeParam T - Callback result type
+ */
+type TransactionCallback<T> = Parameters<LibSQLTransactionExecutor>[0] extends ((tx: infer TTx) => Promise<unknown>) ? (tx: TTx) => Promise<T> : never;
+/**
+ * Execute a database transaction through a shared transaction seam.
+ *
+ * Transaction work is serialized per database instance. SQLite permits only
+ * one active transaction on a connection; without this queue, concurrent bus
+ * handlers can fail at `BEGIN` with SQLITE_BUSY before busy_timeout can help.
+ *
+ * **Driver compatibility:** `MakaioDatabase` is typed as `LibSQLDatabase`
+ * (Node.js async dialect), which runs the transaction asynchronously and
+ * returns `Promise<T>`.  At runtime under Bun, `db` is a `BunSQLiteDatabase`
+ * cast to `MakaioDatabase`; the sync dialect propagates the async callback's
+ * return value, so the transaction still resolves as `Promise<T>`, which
+ * `await` unwraps normally.
+ * @param db - Makaio database instance
+ * @param callback - Transaction work to execute
+ * @returns Result returned by the callback
+ */
+declare function executeTransaction<T>(db: MakaioDatabase, callback: TransactionCallback<T>): Promise<T>;
+//#endregion
+//#region storage/drizzle/src/fts.d.ts
+/**
+ * FTS5 query utilities for SQLite full-text search.
+ */
+/**
+ * Sanitizes a user query for safe use in FTS5 MATCH expressions.
+ *
+ * Each whitespace-delimited token is individually quoted to prevent FTS5
+ * syntax injection (via operators like `OR`, `AND`, `NOT`, `*`, `^`) while
+ * preserving multi-term implicit AND matching. Internal double-quote
+ * characters are escaped as two consecutive double quotes per the FTS5
+ * phrase-quoting convention.
+ * @example
+ * sanitizeFtsQuery('typescript generics') // → '"typescript" "generics"'
+ * sanitizeFtsQuery('a "broken quote')     // → '"a" """broken" "quote"'
+ * sanitizeFtsQuery('')                    // → '""'
+ * @param query - Raw user input
+ * @returns Sanitized FTS5 query string with each token individually quoted
+ */
+declare function sanitizeFtsQuery(query: string): string;
+//#endregion
+//#region storage/drizzle/src/result.d.ts
+/**
+ * Cross-driver result helpers for Drizzle write operations.
+ *
+ * The libsql dialect returns `{ rowsAffected: number }` while the bun-sqlite
+ * dialect returns `{ changes: number }`. Consumers must not depend on either
+ * field directly — use {@link didAffectRows} to normalise across drivers.
+ * @packageDocumentation
+ */
+/**
+ * Shape emitted by Drizzle write operations across all supported drivers.
+ *
+ * The libsql (Node.js) driver populates `rowsAffected`; the bun-sqlite driver
+ * populates `changes`. Both may be present when a future driver version unifies
+ * the surface; either being absent is normal.
+ */
+interface DrizzleWriteResult {
+  readonly rowsAffected?: number | null;
+  readonly changes?: number | null;
+}
+/**
+ * Determine whether a Drizzle write operation mutated at least one row.
+ *
+ * Normalises the driver-specific result shape so callers do not need to know
+ * which SQLite dialect is active at runtime.
+ * @param result - Write result from a Drizzle `insert`, `update`, or `delete`.
+ * @returns `true` when one or more rows were affected.
+ */
+declare function didAffectRows(result: DrizzleWriteResult): boolean;
+/**
+ * Extract the affected row count from a Drizzle write result.
+ *
+ * Returns the driver-appropriate count regardless of whether the libsql or
+ * bun-sqlite dialect is active.
+ * @param result - Write result from a Drizzle `insert`, `update`, or `delete`.
+ * @returns Number of affected rows, defaulting to `0` when neither field is set.
+ */
+declare function affectedRowCount(result: DrizzleWriteResult): number;
+//#endregion
+//#region storage/drizzle/src/register-handlers.d.ts
+/**
+ * Typed storage handler registration callback with `db` narrowed to
+ * {@link MakaioDatabase}.
+ *
+ * Use this as the argument type for your handler registration function when
+ * wrapping it with {@link registerDrizzleHandlers}.
+ * @typeParam TSchema - Drizzle table schema record. Defaults to an empty schema.
+ */
+type DrizzleHandlerRegistration<TSchema extends Record<string, unknown> = Record<string, never>> = (bus: IMakaioBus, db: MakaioDatabase<TSchema>, ctx: ExtensionContext) => (() => void) | void;
+/**
+ * Wraps a typed Drizzle handler registration into the
+ * `(bus, db: unknown, ctx) => ...` shape required by
+ * {@link MakaioExtension.storage.registerHandlers}.
+ *
+ * The single `db as MakaioDatabase` cast lives here — at the Drizzle
+ * boundary — so package authors receive a fully-typed `db` without
+ * repeating the unsafe cast at every registration site.
+ * @param registration - Typed handler registration callback.
+ * @returns Opaque callback compatible with the contracts-layer signature.
+ */
+declare function registerDrizzleHandlers<TSchema extends Record<string, unknown> = Record<string, never>>(registration: DrizzleHandlerRegistration<TSchema>): (bus: IMakaioBus, db: unknown, ctx: ExtensionContext) => (() => void) | void;
+//#endregion
+//#region storage/drizzle/src/index.d.ts
+/**
+ * Drizzle schema record type.
+ * Maps table names to Drizzle table definitions.
+ */
+type DrizzleSchemaRecord = Record<string, Table>;
+declare module '@makaio/framework/storage' {
+  interface StorageNamespaceExtensions {
+    /**
+     * Drizzle ORM table schemas for this storage domain.
+     * Contains table definitions that can be used by Drizzle-based storage services.
+     */
+    drizzle?: DrizzleSchemaRecord;
+  }
+}
+//#endregion
+export { type DrizzleHandlerRegistration, DrizzleSchemaRecord, type MakaioDatabase, type StorageNamespace, type StorageNamespaceConfig, type StorageNamespaceExtensions, type TransactionCallback, affectedRowCount, createStorageNamespace, didAffectRows, executeTransaction, registerDrizzleHandlers, sanitizeFtsQuery };

package/dist/storage/drizzle/index.mjs

@@ -0,0 +1 @@
+import{createStorageNamespace as e}from"@makaio/framework/storage";async function t(e,t){let r=n.get(e)??Promise.resolve(),i=()=>{},a=new Promise(e=>{i=e}),o=r.catch(()=>void 0).then(()=>a);n.set(e,o),await r.catch(()=>void 0);try{return await e.transaction(t)}finally{i(),n.get(e)===o&&n.delete(e)}}const n=new WeakMap;function r(e){let t=e.trim().split(/\s+/).filter(Boolean);return t.length===0?`""`:t.map(e=>`"${e.replace(/"/g,`""`)}"`).join(` `)}function i(e){return(e.rowsAffected??e.changes??0)>0}function a(e){return e.rowsAffected??e.changes??0}function o(e){return(t,n,r)=>e(t,n,r)}export{a as affectedRowCount,e as createStorageNamespace,i as didAffectRows,t as executeTransaction,o as registerDrizzleHandlers,r as sanitizeFtsQuery};

package/dist/storage/handlers/drizzle/index.d.mts

@@ -0,0 +1,2 @@
+import { a as DrizzleCrudConfig, i as CrudLifecycleConfig, n as createDrizzleListHandler, o as DrizzleListConfig, r as createDrizzleCrudHandlers, t as buildScopePredicates } from "../../../index-CokQYGVP.mjs";
+export { CrudLifecycleConfig, DrizzleCrudConfig, DrizzleListConfig, buildScopePredicates, createDrizzleCrudHandlers, createDrizzleListHandler };

package/dist/storage/handlers/drizzle/index.mjs

@@ -0,0 +1 @@
+import{n as e,r as t,t as n}from"../../../drizzle-Eq8W1EbD.mjs";export{n as buildScopePredicates,t as createDrizzleCrudHandlers,e as createDrizzleListHandler};

package/dist/storage/handlers/index.d.mts

@@ -0,0 +1,33 @@
+import { a as DrizzleCrudConfig, i as CrudLifecycleConfig, n as createDrizzleListHandler, o as DrizzleListConfig, r as createDrizzleCrudHandlers, t as buildScopePredicates } from "../../index-CokQYGVP.mjs";
+
+//#region storage/handlers/src/utils.d.ts
+/**
+ * Convert null values to undefined for specified keys.
+ * Used when mapping database rows to API types.
+ * @param obj - Source object with nullable fields
+ * @param keys - Keys to convert from null to undefined
+ * @returns New object with null converted to undefined for specified keys
+ * @example
+ * ```typescript
+ * const dbRow = { id: '1', name: 'test', description: null, value: 42 };
+ * const result = nullToUndefined(dbRow, ['description']);
+ * // { id: '1', name: 'test', description: undefined, value: 42 }
+ * ```
+ */
+declare function nullToUndefined<T extends Record<string, unknown>>(obj: T, keys: (keyof T)[]): T;
+/**
+ * Convert undefined values to null for specified keys.
+ * Used when mapping API inputs to database values.
+ * @param obj - Source object with optional fields
+ * @param keys - Keys to convert from undefined to null
+ * @returns New object with undefined converted to null for specified keys
+ * @example
+ * ```typescript
+ * const apiInput = { id: '1', name: 'test', description: undefined, value: 42 };
+ * const result = undefinedToNull(apiInput, ['description']);
+ * // { id: '1', name: 'test', description: null, value: 42 }
+ * ```
+ */
+declare function undefinedToNull<T extends Record<string, unknown>>(obj: T, keys: (keyof T)[]): T;
+//#endregion
+export { type CrudLifecycleConfig, type DrizzleCrudConfig, type DrizzleListConfig, buildScopePredicates, createDrizzleCrudHandlers, createDrizzleListHandler, nullToUndefined, undefinedToNull };

package/dist/storage/handlers/index.mjs

@@ -0,0 +1 @@
+import{n as e,r as t,t as n}from"../../drizzle-Eq8W1EbD.mjs";function r(e,t){let n={...e};for(let e of t)n[e]===null&&(n[e]=void 0);return n}function i(e,t){let n={...e};for(let e of t)n[e]===void 0&&(n[e]=null);return n}export{n as buildScopePredicates,t as createDrizzleCrudHandlers,e as createDrizzleListHandler,r as nullToUndefined,i as undefinedToNull};

package/dist/storage/index.d.mts

@@ -0,0 +1,192 @@
+import { BusNamespaceDefinition, FilterablePayloadIntersection, SchemaRecord, SubjectRecord, SubjectRecordFromSchemaRecord } from "@makaio/framework/core";
+import { BusNamespace } from "@makaio/framework/bus";
+
+//#region storage/core/src/types.d.ts
+/**
+ * Extension point for storage namespace extensions.
+ *
+ * Use declaration merging to add ORM-specific properties:
+ * @example
+ * ```typescript
+ * // In @makaio/storage-drizzle
+ * declare module '@makaio/framework/storage' {
+ *   interface StorageNamespaceExtensions {
+ *     drizzle?: Record<string, Table>;
+ *   }
+ * }
+ * ```
+ */
+interface StorageNamespaceExtensions {}
+/**
+ * Storage namespace combines bus namespace with extensible storage-specific properties.
+ *
+ * Wraps BusNamespace with:
+ * - Automatic 'storage:' prefix for domain naming
+ * - Extension point for ORM schemas via declaration merging
+ * @typeParam N - Storage domain name (without 'storage:' prefix)
+ * @typeParam Subjects - Subject record type from schemas
+ * @typeParam FilterPayload - Filter payload type for type-safe filtering
+ * @typeParam Ext - Extension type preserving specific table types
+ * @typeParam Schemas - Original schema record; drives narrow literal types on subjects.$meta
+ */
+interface StorageNamespace<N extends string = string, Subjects extends SubjectRecord = SubjectRecord, FilterPayload = unknown, Ext extends StorageNamespaceExtensions = StorageNamespaceExtensions, Schemas extends SchemaRecord = SchemaRecord> extends BusNamespace<`storage:${N}`, Subjects, FilterPayload, Schemas> {
+  /**
+   * Storage domain name (without 'storage:' prefix).
+   */
+  readonly domain: N;
+  /**
+   * Extension properties added via declaration merging.
+   * @see StorageNamespaceExtensions
+   */
+  readonly extensions: Ext;
+}
+/**
+ * Configuration for creating a storage namespace.
+ * @typeParam Schemas - Schema record type for bus subjects
+ * @typeParam Ext - Extension type preserving specific table types
+ */
+interface StorageNamespaceConfig<Schemas extends SchemaRecord, Ext extends StorageNamespaceExtensions = StorageNamespaceExtensions> {
+  /**
+   * Bus subject schemas for storage operations.
+   * Typically includes get, set, delete, list operations.
+   */
+  schemas: Schemas;
+  /**
+   * Extension properties (populated by declaration merging).
+   * @see StorageNamespaceExtensions
+   */
+  extensions?: Ext;
+}
+/**
+ * Infer the storage namespace type from config.
+ */
+type StorageNamespaceFromConfig<N extends string, Schemas extends SchemaRecord> = StorageNamespace<N, SubjectRecordFromSchemaRecord<Schemas>, FilterablePayloadIntersection<SubjectRecordFromSchemaRecord<Schemas>>, StorageNamespaceExtensions, Schemas>;
+//#endregion
+//#region storage/core/src/create-storage-namespace-definition.d.ts
+/**
+ * A declarative storage namespace definition.
+ *
+ * Created by {@link createStorageNamespaceDefinition}. Extends
+ * {@link BusNamespaceDefinition} with storage-specific fields (`domain`,
+ * `extensions`) and carries typed subject tokens for immediate use in bus
+ * operations. Registration is deferred until
+ * `createStorageNamespace(definition)` is called at a composition root.
+ * @typeParam N - Storage domain name without the `'storage:'` prefix
+ * @typeParam Schemas - Schema record mapping subject keys to Zod schemas
+ * @typeParam Ext - Extension type preserving specific ORM table types
+ */
+interface StorageNamespaceDefinition<N extends string = string, Schemas extends SchemaRecord = SchemaRecord, Ext extends StorageNamespaceExtensions = StorageNamespaceExtensions> extends BusNamespaceDefinition<`storage:${N}`, Schemas> {
+  /**
+   * Storage domain name without the `'storage:'` prefix (e.g., `'session'`).
+   */
+  readonly domain: N;
+  /**
+   * Extension properties added via declaration merging.
+   * @see StorageNamespaceExtensions
+   */
+  readonly extensions: Ext;
+}
+/**
+ * Creates a storage namespace definition with typed subject tokens.
+ *
+ * Pure function — no side-effects, no bus singleton mutation. The returned
+ * definition can be used immediately for bus operations (`bus.on()`,
+ * `bus.emit()`, etc.) and registered later at a composition root via
+ * `createStorageNamespace(definition)`.
+ * @param domain - Storage domain name without the `'storage:'` prefix
+ *   (e.g., `'session'` becomes `'storage:session'`)
+ * @param config - Namespace configuration with schemas and optional extensions
+ * @returns Storage namespace definition with typed subject tokens and carried
+ *   schemas
+ * @example
+ * ```typescript
+ * import { createStorageNamespaceDefinition } from '@makaio/framework/storage';
+ * import { z } from 'zod';
+ *
+ * export const SessionStorageDefinition = createStorageNamespaceDefinition('session', {
+ *   schemas: {
+ *     get: { request: z.object({ sessionId: z.string() }), response: SessionSchema },
+ *     set: { request: z.object({ sessionId: z.string(), session: SessionSchema }), response: SuccessSchema },
+ *   },
+ * });
+ *
+ * // Subjects are immediately available without registration:
+ * bus.on(SessionStorageDefinition.subjects.get, handler);
+ * ```
+ */
+declare function createStorageNamespaceDefinition<N extends string, Schemas extends SchemaRecord, Ext extends StorageNamespaceExtensions = StorageNamespaceExtensions>(domain: N, config: StorageNamespaceConfig<Schemas, Ext>): StorageNamespaceDefinition<N, Schemas, Ext>;
+//#endregion
+//#region storage/core/src/create-storage-namespace.d.ts
+/**
+ * Registers a storage namespace definition on the bus singleton.
+ *
+ * Accepts a {@link StorageNamespaceDefinition} created by
+ * {@link createStorageNamespaceDefinition} and registers it with
+ * `MakaioBus.registerNamespace()`. Returns a {@link StorageNamespace} that
+ * additionally exposes `scopedBus()` for scoped bus operations.
+ *
+ * Call this function at composition roots (app entry-points, service
+ * constructors) — never in module scope where the bus singleton may not yet
+ * be ready.
+ * @param definition - Storage namespace definition created by
+ *   `createStorageNamespaceDefinition()`
+ * @returns Storage namespace with typed subjects, `scopedBus()`, and
+ *   extensions
+ * @example
+ * ```typescript
+ * // At module level (pure, no side-effects):
+ * export const SessionStorageDefinition = createStorageNamespaceDefinition('session', {
+ *   schemas: {
+ *     get: { request: z.object({ id: z.string() }), response: z.object({ data: DataSchema }) },
+ *     set: { request: z.object({ id: z.string(), data: DataSchema }), response: z.object({ success: z.boolean() }) },
+ *   },
+ * });
+ *
+ * // At composition root (registers on the bus):
+ * const SessionStorage = createStorageNamespace(SessionStorageDefinition);
+ * await bus.request(SessionStorage.subjects.get, { id: '123' });
+ * ```
+ */
+declare function createStorageNamespace<N extends string, Schemas extends SchemaRecord, Ext extends StorageNamespaceExtensions = StorageNamespaceExtensions>(definition: StorageNamespaceDefinition<N, Schemas, Ext>): StorageNamespace<N, SubjectRecordFromSchemaRecord<Schemas>, FilterablePayloadIntersection<SubjectRecordFromSchemaRecord<Schemas>>, Ext, Schemas>;
+//#endregion
+//#region storage/core/src/create-extension-storage-namespace.d.ts
+type Whitespace = ' ' | '\n' | '\r' | '\t' | '\v' | '\f' | '\u00A0' | '\u1680' | '\u2000' | '\u2001' | '\u2002' | '\u2003' | '\u2004' | '\u2005' | '\u2006' | '\u2007' | '\u2008' | '\u2009' | '\u200A' | '\u2028' | '\u2029' | '\u202F' | '\u205F' | '\u3000' | '\uFEFF';
+type TrimLeft<T extends string> = T extends `${Whitespace}${infer Rest}` ? TrimLeft<Rest> : T;
+type TrimRight<T extends string> = T extends `${infer Rest}${Whitespace}` ? TrimRight<Rest> : T;
+type Trim<T extends string> = string extends T ? string : TrimLeft<TrimRight<T>>;
+/**
+ * Creates a storage namespace for an extension with typed subject definitions.
+ *
+ * Pure wrapper around {@link createStorageNamespaceDefinition} that:
+ * - Automatically prepends `'extension:'` to the extension name before
+ *   creating the storage namespace
+ * - Results in namespaces like `'storage:extension:terminal'`
+ * - Preserves all storage namespace capabilities (ORM extensions, type-safe
+ *   filtering)
+ * @param extensionName - Extension name (e.g., `'terminal'` becomes
+ *   `'storage:extension:terminal'`)
+ * @param config - Storage namespace configuration with schemas and optional
+ *   extensions
+ * @returns Storage namespace with typed subjects and extensions
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const TerminalStorage = createExtensionStorageNamespace('terminal', {
+ *   schemas: {
+ *     get: { request: z.object({ id: z.string() }), response: z.object({ data: DataSchema }) },
+ *     set: { request: z.object({ id: z.string(), data: DataSchema }), response: z.object({ success: z.boolean() }) },
+ *   },
+ * });
+ *
+ * // With drizzle extension (after importing @makaio/storage-drizzle)
+ * const TerminalStorage = createExtensionStorageNamespace('terminal', {
+ *   schemas: { ... },
+ *   extensions: {
+ *     drizzle: { terminals: terminalsTable },
+ *   },
+ * });
+ * ```
+ */
+declare function createExtensionStorageNamespace<N extends string, Schemas extends SchemaRecord, Ext extends StorageNamespaceExtensions = StorageNamespaceExtensions>(extensionName: N, config: StorageNamespaceConfig<Schemas, Ext>): StorageNamespaceDefinition<`extension:${Trim<N>}`, Schemas, Ext>;
+//#endregion
+export { type StorageNamespace, type StorageNamespaceConfig, type StorageNamespaceDefinition, type StorageNamespaceExtensions, type StorageNamespaceFromConfig, createExtensionStorageNamespace, createStorageNamespace, createStorageNamespaceDefinition };

package/dist/storage/index.mjs

@@ -0,0 +1 @@
+import{createBusNamespace as e}from"@makaio/framework/core";import{MakaioBus as t}from"@makaio/framework/bus";function n(e){return{...t.registerNamespace(e),domain:e.domain,extensions:e.extensions}}function r(t,n){return{...e(`storage:${t}`,n.schemas),domain:t,extensions:n.extensions??{}}}function i(e,t){let n=e.trim();if(n.length===0||n.startsWith(`extension:`))throw Error(`Invalid extensionName: expected a non-empty extension name without the "extension:" prefix.`);return r(`extension:${n}`,t)}export{i as createExtensionStorageNamespace,n as createStorageNamespace,r as createStorageNamespaceDefinition};

package/dist/storage-namespace-BXkoh5Sy.d.mts

@@ -0,0 +1,221 @@
+import * as _$zod from "zod";
+import * as _$_makaio_core0 from "@makaio/framework/core";
+import * as _$zod_v4_core0 from "zod/v4/core";
+
+//#region services/core/src/preferences/storage-namespace.d.ts
+/**
+ * Preferences namespace definition.
+ */
+declare const PreferencesNamespace: _$_makaio_core0.BusNamespaceDefinition<"preferences", {
+  get: {
+    request: _$zod.ZodObject<{
+      key: _$zod.ZodObject<{
+        surface: _$zod.ZodOptional<_$zod.ZodEnum<{
+          ui: "ui";
+          app: "app";
+        }>>;
+        scope: _$zod.ZodString;
+        context: _$zod.ZodOptional<_$zod.ZodString>;
+        viewport: _$zod.ZodOptional<_$zod.ZodEnum<{
+          mobile: "mobile";
+          desktop: "desktop";
+          tablet: "tablet";
+        }>>;
+      }, _$zod_v4_core0.$strip>;
+      category: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      value: _$zod.ZodNullable<_$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>>;
+    }, _$zod_v4_core0.$strip>;
+  };
+  set: {
+    request: _$zod.ZodObject<{
+      key: _$zod.ZodObject<{
+        surface: _$zod.ZodOptional<_$zod.ZodEnum<{
+          ui: "ui";
+          app: "app";
+        }>>;
+        scope: _$zod.ZodString;
+        context: _$zod.ZodOptional<_$zod.ZodString>;
+        viewport: _$zod.ZodOptional<_$zod.ZodEnum<{
+          mobile: "mobile";
+          desktop: "desktop";
+          tablet: "tablet";
+        }>>;
+      }, _$zod_v4_core0.$strip>;
+      category: _$zod.ZodString;
+      value: _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      success: _$zod.ZodBoolean;
+    }, _$zod_v4_core0.$strip>;
+  };
+  delete: {
+    request: _$zod.ZodObject<{
+      key: _$zod.ZodObject<{
+        surface: _$zod.ZodOptional<_$zod.ZodEnum<{
+          ui: "ui";
+          app: "app";
+        }>>;
+        scope: _$zod.ZodString;
+        context: _$zod.ZodOptional<_$zod.ZodString>;
+        viewport: _$zod.ZodOptional<_$zod.ZodEnum<{
+          mobile: "mobile";
+          desktop: "desktop";
+          tablet: "tablet";
+        }>>;
+      }, _$zod_v4_core0.$strip>;
+      category: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      success: _$zod.ZodBoolean;
+    }, _$zod_v4_core0.$strip>;
+  };
+  list: {
+    request: _$zod.ZodObject<{
+      key: _$zod.ZodOptional<_$zod.ZodObject<{
+        surface: _$zod.ZodOptional<_$zod.ZodOptional<_$zod.ZodEnum<{
+          ui: "ui";
+          app: "app";
+        }>>>;
+        scope: _$zod.ZodOptional<_$zod.ZodString>;
+        context: _$zod.ZodOptional<_$zod.ZodOptional<_$zod.ZodString>>;
+        viewport: _$zod.ZodOptional<_$zod.ZodOptional<_$zod.ZodEnum<{
+          mobile: "mobile";
+          desktop: "desktop";
+          tablet: "tablet";
+        }>>>;
+      }, _$zod_v4_core0.$strip>>;
+      category: _$zod.ZodOptional<_$zod.ZodString>;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      items: _$zod.ZodArray<_$zod.ZodObject<{
+        key: _$zod.ZodObject<{
+          surface: _$zod.ZodOptional<_$zod.ZodEnum<{
+            ui: "ui";
+            app: "app";
+          }>>;
+          scope: _$zod.ZodString;
+          context: _$zod.ZodOptional<_$zod.ZodString>;
+          viewport: _$zod.ZodOptional<_$zod.ZodEnum<{
+            mobile: "mobile";
+            desktop: "desktop";
+            tablet: "tablet";
+          }>>;
+        }, _$zod_v4_core0.$strip>;
+        category: _$zod.ZodString;
+        value: _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>;
+        updatedAt: _$zod.ZodNumber;
+      }, _$zod_v4_core0.$strip>>;
+    }, _$zod_v4_core0.$strip>;
+  };
+}>;
+/**
+ * Preferences subjects for bus communication.
+ */
+declare const PreferencesSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"preferences", {
+  get: {
+    request: _$zod.ZodObject<{
+      key: _$zod.ZodObject<{
+        surface: _$zod.ZodOptional<_$zod.ZodEnum<{
+          ui: "ui";
+          app: "app";
+        }>>;
+        scope: _$zod.ZodString;
+        context: _$zod.ZodOptional<_$zod.ZodString>;
+        viewport: _$zod.ZodOptional<_$zod.ZodEnum<{
+          mobile: "mobile";
+          desktop: "desktop";
+          tablet: "tablet";
+        }>>;
+      }, _$zod_v4_core0.$strip>;
+      category: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      value: _$zod.ZodNullable<_$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>>;
+    }, _$zod_v4_core0.$strip>;
+  };
+  set: {
+    request: _$zod.ZodObject<{
+      key: _$zod.ZodObject<{
+        surface: _$zod.ZodOptional<_$zod.ZodEnum<{
+          ui: "ui";
+          app: "app";
+        }>>;
+        scope: _$zod.ZodString;
+        context: _$zod.ZodOptional<_$zod.ZodString>;
+        viewport: _$zod.ZodOptional<_$zod.ZodEnum<{
+          mobile: "mobile";
+          desktop: "desktop";
+          tablet: "tablet";
+        }>>;
+      }, _$zod_v4_core0.$strip>;
+      category: _$zod.ZodString;
+      value: _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      success: _$zod.ZodBoolean;
+    }, _$zod_v4_core0.$strip>;
+  };
+  delete: {
+    request: _$zod.ZodObject<{
+      key: _$zod.ZodObject<{
+        surface: _$zod.ZodOptional<_$zod.ZodEnum<{
+          ui: "ui";
+          app: "app";
+        }>>;
+        scope: _$zod.ZodString;
+        context: _$zod.ZodOptional<_$zod.ZodString>;
+        viewport: _$zod.ZodOptional<_$zod.ZodEnum<{
+          mobile: "mobile";
+          desktop: "desktop";
+          tablet: "tablet";
+        }>>;
+      }, _$zod_v4_core0.$strip>;
+      category: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      success: _$zod.ZodBoolean;
+    }, _$zod_v4_core0.$strip>;
+  };
+  list: {
+    request: _$zod.ZodObject<{
+      key: _$zod.ZodOptional<_$zod.ZodObject<{
+        surface: _$zod.ZodOptional<_$zod.ZodOptional<_$zod.ZodEnum<{
+          ui: "ui";
+          app: "app";
+        }>>>;
+        scope: _$zod.ZodOptional<_$zod.ZodString>;
+        context: _$zod.ZodOptional<_$zod.ZodOptional<_$zod.ZodString>>;
+        viewport: _$zod.ZodOptional<_$zod.ZodOptional<_$zod.ZodEnum<{
+          mobile: "mobile";
+          desktop: "desktop";
+          tablet: "tablet";
+        }>>>;
+      }, _$zod_v4_core0.$strip>>;
+      category: _$zod.ZodOptional<_$zod.ZodString>;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      items: _$zod.ZodArray<_$zod.ZodObject<{
+        key: _$zod.ZodObject<{
+          surface: _$zod.ZodOptional<_$zod.ZodEnum<{
+            ui: "ui";
+            app: "app";
+          }>>;
+          scope: _$zod.ZodString;
+          context: _$zod.ZodOptional<_$zod.ZodString>;
+          viewport: _$zod.ZodOptional<_$zod.ZodEnum<{
+            mobile: "mobile";
+            desktop: "desktop";
+            tablet: "tablet";
+          }>>;
+        }, _$zod_v4_core0.$strip>;
+        category: _$zod.ZodString;
+        value: _$zod.ZodType<unknown, unknown, _$zod_v4_core0.$ZodTypeInternals<unknown, unknown>>;
+        updatedAt: _$zod.ZodNumber;
+      }, _$zod_v4_core0.$strip>>;
+    }, _$zod_v4_core0.$strip>;
+  };
+}>, "preferences">;
+//#endregion
+export { PreferencesSubjects as n, PreferencesNamespace as t };

package/dist/storage-namespace-DWsYLAXa.mjs

@@ -0,0 +1 @@
+import{t as e}from"./schemas-CVvwIfG4.mjs";import{z as t}from"zod";import{createBusNamespace as n}from"@makaio/framework/core";import{createStorageNamespaceDefinition as r}from"@makaio/framework/storage";const i=`contextRules`,a=[`AGENTS.md`,`CLAUDE.md`,`GEMINI.md`,`COPILOT.md`,`CURSOR.md`],o=t.object({cwd:t.string().optional(),adapterId:t.string().optional(),sessionId:t.string().optional(),agentId:t.string().optional()}).strict(),s=o.catchall(t.unknown()),c=t.enum(a),l=t.object({channel:t.literal(`turnContext`),content:t.string(),turnContextKey:t.string().optional()}).strict(),u=t.object({channel:t.literal(`file`),content:t.string(),fileTarget:c}).strict(),d=t.discriminatedUnion(`channel`,[l,u]),f=t.enum([`global`,`project`,`session`]);function p(e){return e.scope===`global`?e.projectId!==void 0||e.sessionId!==void 0?[{path:[`projectId`],message:`Global scope context rules must not have projectId or sessionId`}]:[]:e.scope===`project`?e.projectId?e.sessionId===void 0?[]:[{path:[`sessionId`],message:`Project scope context rules must not have sessionId`}]:[{path:[`projectId`],message:`Project scope context rules require projectId`}]:e.sessionId?[]:[{path:[`sessionId`],message:`Session scope context rules require sessionId`}]}function m(e){let[t]=p(e);if(t)throw Error(t.message)}const h=t.object({id:t.string().min(1),name:t.string().min(1),description:t.string().optional(),condition:e,action:d,priority:t.number(),enabled:t.boolean(),scope:f,projectId:t.string().optional(),sessionId:t.string().optional()}).strict(),g=h.superRefine((e,t)=>{for(let n of p(e))t.addIssue({code:`custom`,path:n.path,message:n.message})}),_=h.extend({createdAt:t.number(),updatedAt:t.number()}).superRefine((e,t)=>{for(let n of p(e))t.addIssue({code:`custom`,path:n.path,message:n.message})}),v=t.object({projectId:t.string().optional(),sessionId:t.string().optional()}).strict(),y=t.object({scope:f,projectId:t.string().nullable(),sessionId:t.string().nullable()}).strict(),b=o,x=t.object({id:t.string(),name:t.string(),priority:t.number(),action:d,renderedContent:t.string()}).strict(),S=t.object(Object.fromEntries(a.map(e=>[e,t.array(x).optional()]))).strict(),C=t.object({snapshot:s,turnContext:t.record(t.string(),t.array(x)),files:S}).strict(),w=t.object({ruleId:t.string(),changeType:t.enum([`created`,`updated`,`deleted`]),previous:y.nullable(),current:y.nullable(),timestamp:t.number()}).strict(),T=n(`contextRules`,{resolve:{request:b,response:C},changed:w}),E=T.subjects,D=r(`contextRules`,{schemas:{get:{request:t.object({id:t.string()}),response:t.object({rule:_.nullable()})},set:{request:t.object({rule:g}),response:t.object({id:t.string()})},delete:{request:t.object({id:t.string()}),response:t.object({deleted:t.boolean()})},list:{request:v,response:t.object({rules:t.array(_)})}}}),O=D.subjects;export{a as S,x as _,d as a,m as b,v as c,y as d,f,c as g,u as h,E as i,b as l,s as m,O as n,w as o,o as p,T as r,g as s,D as t,_ as u,C as v,i as x,l as y};

package/dist/storage-namespace-definition-Bkx5rSto.d.mts

@@ -0,0 +1,17 @@
+import { BusNamespaceDefinition, SchemaRecord } from "@makaio/framework/core";
+
+//#region core/contracts/src/storage-namespace-definition.d.ts
+/**
+ * Declarative storage namespace definition used by contracts.
+ *
+ * This mirrors the public shape consumed by storage runtimes without importing
+ * `@makaio/storage-core`, keeping `@makaio/contracts` pure.
+ */
+interface ContractStorageNamespaceDefinition<Domain extends string = string, Schemas extends SchemaRecord = SchemaRecord, Extensions extends Record<string, unknown> = Record<string, never>> extends BusNamespaceDefinition<`storage:${Domain}`, Schemas> {
+  /** Storage domain without the `storage:` prefix. */
+  readonly domain: Domain;
+  /** Optional storage metadata carried for runtime handler wiring. */
+  readonly extensions: Extensions;
+}
+//#endregion
+export { ContractStorageNamespaceDefinition as t };

package/dist/storage-namespace-definition-CqSdsuCC.mjs

@@ -0,0 +1 @@
+import{createBusNamespace as e}from"@makaio/framework/core";function t(t,n){return{...e(`storage:${t}`,n.schemas),domain:t,extensions:n.extensions??{}}}export{t};