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

package/dist/index-472sOmsW.d.mts

@@ -0,0 +1,218 @@
+import * as _$zod from "zod";
+import { z } from "zod";
+import * as _$_makaio_core0 from "@makaio/framework/core";
+import * as _$zod_v4_core0 from "zod/v4/core";
+
+//#region core/contracts/src/variant/schemas.d.ts
+/**
+ * Supported build variant identifiers for the Electrobun desktop host.
+ *
+ * - `'base'` — system WebView (no bundled CEF)
+ * - `'cef'` — Chromium Embedded Framework bundled into the distributable
+ */
+declare const MakaioVariantSchema: z.ZodEnum<{
+  base: "base";
+  cef: "cef";
+}>;
+/** Inferred TypeScript type for a variant identifier. */
+type MakaioVariant = z.infer<typeof MakaioVariantSchema>;
+/**
+ * Upgrade status values emitted during a variant upgrade operation.
+ *
+ * - `'downloading'` — initiating download
+ * - `'progress'` — download in progress
+ * - `'applying'` — applying the downloaded files
+ * - `'complete'` — upgrade finished successfully
+ * - `'error'` — upgrade failed
+ */
+declare const VariantUpgradeStatusSchema: z.ZodEnum<{
+  error: "error";
+  complete: "complete";
+  progress: "progress";
+  downloading: "downloading";
+  applying: "applying";
+}>;
+/** Inferred TypeScript type for an upgrade status value. */
+type VariantUpgradeStatus = z.infer<typeof VariantUpgradeStatusSchema>;
+/**
+ * Variant domain bus schemas.
+ *
+ * Each key becomes a subject identifier as `host:variant.<key>`.
+ */
+declare const VariantSchemas: {
+  /**
+   * Query the current variant configuration from the host.
+   *
+   * Request: empty — the handler reads the resolved variant at startup.
+   * Response: full variant info — identifier, CEF-bundle flag, and default renderer.
+   *
+   * Subject: `host:variant.getInfo`
+   * Type: Request (RPC)
+   */
+  getInfo: {
+    request: z.ZodObject<{}, z.core.$strip>;
+    response: z.ZodObject<{
+      variant: z.ZodEnum<{
+        base: "base";
+        cef: "cef";
+      }>;
+      bundleCEF: z.ZodBoolean;
+      defaultRenderer: z.ZodEnum<{
+        native: "native";
+        cef: "cef";
+      }>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Request a variant switch on the host.
+   *
+   * The host may accept or decline the request. When accepted it may report
+   * the estimated download size so the caller can display a confirmation UI.
+   * A declined response must include a human-readable `message` explaining why.
+   *
+   * Subject: `host:variant.requestUpgrade`
+   * Type: Request (RPC)
+   */
+  requestUpgrade: {
+    request: z.ZodObject<{
+      targetVariant: z.ZodEnum<{
+        base: "base";
+        cef: "cef";
+      }>;
+    }, z.core.$strip>;
+    response: z.ZodUnion<readonly [z.ZodObject<{
+      accepted: z.ZodLiteral<true>;
+      downloadSizeBytes: z.ZodOptional<z.ZodNumber>;
+      message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      accepted: z.ZodLiteral<false>;
+      message: z.ZodString;
+    }, z.core.$strip>]>;
+  };
+  /**
+   * Emitted by the host while a variant upgrade is in progress.
+   *
+   * Consumers subscribe to track download and apply progress for display
+   * in the UI (e.g. a progress bar).
+   *
+   * Subject: `host:variant.upgradeProgress`
+   * Type: Event
+   */
+  upgradeProgress: z.ZodObject<{
+    status: z.ZodEnum<{
+      error: "error";
+      complete: "complete";
+      progress: "progress";
+      downloading: "downloading";
+      applying: "applying";
+    }>;
+    percent: z.ZodOptional<z.ZodNumber>;
+    message: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+};
+/** Response payload for `host:variant.getInfo`. */
+type VariantGetInfoResponse = z.infer<(typeof VariantSchemas)['getInfo']['response']>;
+/** Request payload for `host:variant.requestUpgrade`. */
+type VariantRequestUpgradeRequest = z.infer<(typeof VariantSchemas)['requestUpgrade']['request']>;
+/** Response payload for `host:variant.requestUpgrade`. */
+type VariantRequestUpgradeResponse = z.infer<(typeof VariantSchemas)['requestUpgrade']['response']>;
+/** Payload of the `host:variant.upgradeProgress` event. */
+type VariantUpgradeProgressEvent = z.infer<(typeof VariantSchemas)['upgradeProgress']>;
+//#endregion
+//#region core/contracts/src/variant/namespace.d.ts
+/**
+ * Variant namespace definition.
+ * Provides typed subjects for variant detection and upgrade operations.
+ */
+declare const VariantNamespace: _$_makaio_core0.BusNamespaceDefinition<"host:variant", {
+  getInfo: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      variant: _$zod.ZodEnum<{
+        base: "base";
+        cef: "cef";
+      }>;
+      bundleCEF: _$zod.ZodBoolean;
+      defaultRenderer: _$zod.ZodEnum<{
+        native: "native";
+        cef: "cef";
+      }>;
+    }, _$zod_v4_core0.$strip>;
+  };
+  requestUpgrade: {
+    request: _$zod.ZodObject<{
+      targetVariant: _$zod.ZodEnum<{
+        base: "base";
+        cef: "cef";
+      }>;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodUnion<readonly [_$zod.ZodObject<{
+      accepted: _$zod.ZodLiteral<true>;
+      downloadSizeBytes: _$zod.ZodOptional<_$zod.ZodNumber>;
+      message: _$zod.ZodOptional<_$zod.ZodString>;
+    }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
+      accepted: _$zod.ZodLiteral<false>;
+      message: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>]>;
+  };
+  upgradeProgress: _$zod.ZodObject<{
+    status: _$zod.ZodEnum<{
+      error: "error";
+      complete: "complete";
+      progress: "progress";
+      downloading: "downloading";
+      applying: "applying";
+    }>;
+    percent: _$zod.ZodOptional<_$zod.ZodNumber>;
+    message: _$zod.ZodOptional<_$zod.ZodString>;
+  }, _$zod_v4_core0.$strip>;
+}>;
+/**
+ * Variant subjects for type-safe bus operations.
+ * Use these with MakaioBus.request(), MakaioBus.on(), etc.
+ */
+declare const VariantSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"host:variant", {
+  getInfo: {
+    request: _$zod.ZodObject<{}, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodObject<{
+      variant: _$zod.ZodEnum<{
+        base: "base";
+        cef: "cef";
+      }>;
+      bundleCEF: _$zod.ZodBoolean;
+      defaultRenderer: _$zod.ZodEnum<{
+        native: "native";
+        cef: "cef";
+      }>;
+    }, _$zod_v4_core0.$strip>;
+  };
+  requestUpgrade: {
+    request: _$zod.ZodObject<{
+      targetVariant: _$zod.ZodEnum<{
+        base: "base";
+        cef: "cef";
+      }>;
+    }, _$zod_v4_core0.$strip>;
+    response: _$zod.ZodUnion<readonly [_$zod.ZodObject<{
+      accepted: _$zod.ZodLiteral<true>;
+      downloadSizeBytes: _$zod.ZodOptional<_$zod.ZodNumber>;
+      message: _$zod.ZodOptional<_$zod.ZodString>;
+    }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
+      accepted: _$zod.ZodLiteral<false>;
+      message: _$zod.ZodString;
+    }, _$zod_v4_core0.$strip>]>;
+  };
+  upgradeProgress: _$zod.ZodObject<{
+    status: _$zod.ZodEnum<{
+      error: "error";
+      complete: "complete";
+      progress: "progress";
+      downloading: "downloading";
+      applying: "applying";
+    }>;
+    percent: _$zod.ZodOptional<_$zod.ZodNumber>;
+    message: _$zod.ZodOptional<_$zod.ZodString>;
+  }, _$zod_v4_core0.$strip>;
+}>, "host:variant">;
+//#endregion
+export { VariantGetInfoResponse as a, VariantSchemas as c, VariantUpgradeStatusSchema as d, MakaioVariantSchema as i, VariantUpgradeProgressEvent as l, VariantSubjects as n, VariantRequestUpgradeRequest as o, MakaioVariant as r, VariantRequestUpgradeResponse as s, VariantNamespace as t, VariantUpgradeStatus as u };

package/dist/index-8SZkg7s6.d.mts

@@ -0,0 +1,353 @@
+import { z } from "zod";
+import * as _$_makaio_core0 from "@makaio/framework/core";
+
+//#region core/contracts/src/facet/schemas.d.ts
+/**
+ * Authority actors permitted to assert or modify a facet value.
+ *
+ * - `'human'` — end-user acting through the UI or a client tool
+ * - `'system'` — runtime infrastructure (e.g., lifecycle rules)
+ * - `'agent'` — an AI or automated agent operating in a session
+ */
+declare const FacetAuthoritySchema: z.ZodEnum<{
+  agent: "agent";
+  system: "system";
+  human: "human";
+}>;
+/**
+ * Cardinality of values a facet namespace permits per target.
+ *
+ * - `'single'` — at most one value active at a time (e.g., a status field)
+ * - `'multiple'` — several values may coexist (e.g., labels or tags)
+ */
+declare const FacetCardinalitySchema: z.ZodEnum<{
+  single: "single";
+  multiple: "multiple";
+}>;
+/**
+ * Entity classes that a facet namespace may be applied to.
+ *
+ * - `'workpiece'` — a top-level unit of work (e.g., a task or session)
+ * - `'artifact'` — a versioned framework artifact revision
+ * - `'surface'` — a UI surface or layout area
+ */
+declare const FacetAppliesToSchema: z.ZodEnum<{
+  surface: "surface";
+  workpiece: "workpiece";
+  artifact: "artifact";
+}>;
+/**
+ * Serializable registration record for a named facet namespace.
+ *
+ * Facet namespace registrations are declared by framework services and product
+ * extensions, then consumed by the facet service to validate and route facet
+ * assertions. The `namespace` field is a kebab-case identifier unique within
+ * the facet registry.
+ */
+declare const FacetNamespaceRegistrationSchema: z.ZodObject<{
+  namespace: z.ZodString;
+  cardinality: z.ZodEnum<{
+    single: "single";
+    multiple: "multiple";
+  }>;
+  values: z.ZodUnion<readonly [z.ZodLiteral<"open">, z.ZodReadonly<z.ZodArray<z.ZodString>>]>;
+  authority: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+    agent: "agent";
+    system: "system";
+    human: "human";
+  }>>>;
+  appliesTo: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+    surface: "surface";
+    workpiece: "workpiece";
+    artifact: "artifact";
+  }>>>;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Serializable registration record for a named facet namespace. */
+type FacetNamespaceRegistration = z.infer<typeof FacetNamespaceRegistrationSchema>;
+/** Authority actor permitted to assert or modify a facet value. */
+type FacetAuthority = z.infer<typeof FacetAuthoritySchema>;
+/** Cardinality policy for a facet namespace. */
+type FacetCardinality = z.infer<typeof FacetCardinalitySchema>;
+/** Entity class a facet namespace may be applied to. */
+type FacetAppliesTo = z.infer<typeof FacetAppliesToSchema>;
+//#endregion
+//#region core/contracts/src/facet/definition.d.ts
+/**
+ * A facet namespace definition with a serializable registration record.
+ *
+ * Created by {@link defineFacetNamespace}. The definition retains the original
+ * options and produces a bus-transportable {@link FacetNamespaceRegistration}
+ * via `toRegistration()`.
+ *
+ * The interface is intentionally opaque: only `namespace` is exposed directly
+ * so that callers have a stable, lightweight handle on the definition.
+ * All other properties (`cardinality`, `values`, `authority`, `appliesTo`,
+ * `description`) are accessible exclusively through `toRegistration()`, which
+ * also produces the serializable, bus-transportable snapshot. This design
+ * avoids spreading raw mutable fields onto a long-lived definition object and
+ * keeps the contract aligned with the bus registration shape.
+ */
+interface FacetNamespaceDefinition {
+  /** Unique namespace identifier (e.g., `'status'`, `'review-state'`). */
+  readonly namespace: string;
+  /**
+   * Produces a serializable registration record suitable for bus transport.
+   * @returns A {@link FacetNamespaceRegistration} snapshot with all array
+   *   fields copied to prevent shared-reference mutation.
+   */
+  readonly toRegistration: () => FacetNamespaceRegistration;
+}
+/**
+ * Options for {@link defineFacetNamespace}.
+ *
+ * Structurally identical to {@link FacetNamespaceRegistration} — every field
+ * is included in the serializable registration output.
+ */
+type DefineFacetNamespaceOptions = FacetNamespaceRegistration;
+/**
+ * Creates a facet namespace definition with a serializable registration.
+ *
+ * The returned definition exposes the `namespace` identifier directly and
+ * produces a bus-transportable {@link FacetNamespaceRegistration} via
+ * `toRegistration()`. Array fields (`values`, `authority`, `appliesTo`) are
+ * defensively copied so callers cannot mutate the registration snapshot.
+ * @param options - Facet namespace registration options including cardinality,
+ *   values, authority, and the entity classes the facet applies to.
+ * @returns A {@link FacetNamespaceDefinition} with a `toRegistration` method.
+ * @example
+ * ```ts
+ * export const statusFacet = defineFacetNamespace({
+ *   namespace: 'status',
+ *   cardinality: 'single',
+ *   values: ['pending', 'processing', 'blocked', 'completed'],
+ *   authority: ['system'],
+ *   appliesTo: ['workpiece'],
+ * });
+ * ```
+ */
+declare function defineFacetNamespace(options: DefineFacetNamespaceOptions): FacetNamespaceDefinition;
+//#endregion
+//#region core/contracts/src/facet/namespace.d.ts
+/**
+ * Framework-level facet bus schemas.
+ *
+ * Defines the RPC and event subjects for the facet namespace registry.
+ * The schema set covers:
+ *
+ * - `namespace.register` — register a new facet namespace with the facet service (RPC)
+ * - `namespace.list` — query registered facet namespaces (RPC)
+ * - `namespace.changed` — emitted when a facet namespace registration is added or updated (event)
+ *
+ * Product hosts that extend the framework facet namespace should register a
+ * product-owned namespace rather than merging additional subjects into this one.
+ */
+declare const FacetSchemas: {
+  /**
+   * Register a new facet namespace with the facet service (RPC).
+   * Returns `{ registered: true }` when successfully stored.
+   */
+  'namespace.register': {
+    request: z.ZodObject<{
+      namespace: z.ZodString;
+      cardinality: z.ZodEnum<{
+        single: "single";
+        multiple: "multiple";
+      }>;
+      values: z.ZodUnion<readonly [z.ZodLiteral<"open">, z.ZodReadonly<z.ZodArray<z.ZodString>>]>;
+      authority: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        system: "system";
+        human: "human";
+      }>>>;
+      appliesTo: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        surface: "surface";
+        workpiece: "workpiece";
+        artifact: "artifact";
+      }>>>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      registered: z.ZodBoolean;
+    }, z.core.$strip>;
+  }; /** List registered facet namespaces, optionally filtered by namespace string (RPC). */
+  'namespace.list': {
+    request: z.ZodObject<{
+      namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      namespaces: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        cardinality: z.ZodEnum<{
+          single: "single";
+          multiple: "multiple";
+        }>;
+        values: z.ZodUnion<readonly [z.ZodLiteral<"open">, z.ZodReadonly<z.ZodArray<z.ZodString>>]>;
+        authority: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+          agent: "agent";
+          system: "system";
+          human: "human";
+        }>>>;
+        appliesTo: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+          surface: "surface";
+          workpiece: "workpiece";
+          artifact: "artifact";
+        }>>>;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }; /** Emitted when a facet namespace registration is added or updated. */
+  'namespace.changed': z.ZodObject<{
+    namespace: z.ZodString;
+  }, z.core.$strip>;
+};
+/**
+ * Facet bus namespace.
+ *
+ * Registers the `facet` namespace with framework-level RPC and event subjects
+ * for the facet namespace registry. Use `FacetSubjects` to access typed bus
+ * subject descriptors.
+ */
+declare const FacetNamespace: _$_makaio_core0.BusNamespaceDefinition<"facet", {
+  /**
+   * Register a new facet namespace with the facet service (RPC).
+   * Returns `{ registered: true }` when successfully stored.
+   */
+  'namespace.register': {
+    request: z.ZodObject<{
+      namespace: z.ZodString;
+      cardinality: z.ZodEnum<{
+        single: "single";
+        multiple: "multiple";
+      }>;
+      values: z.ZodUnion<readonly [z.ZodLiteral<"open">, z.ZodReadonly<z.ZodArray<z.ZodString>>]>;
+      authority: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        system: "system";
+        human: "human";
+      }>>>;
+      appliesTo: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        surface: "surface";
+        workpiece: "workpiece";
+        artifact: "artifact";
+      }>>>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      registered: z.ZodBoolean;
+    }, z.core.$strip>;
+  }; /** List registered facet namespaces, optionally filtered by namespace string (RPC). */
+  'namespace.list': {
+    request: z.ZodObject<{
+      namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      namespaces: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        cardinality: z.ZodEnum<{
+          single: "single";
+          multiple: "multiple";
+        }>;
+        values: z.ZodUnion<readonly [z.ZodLiteral<"open">, z.ZodReadonly<z.ZodArray<z.ZodString>>]>;
+        authority: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+          agent: "agent";
+          system: "system";
+          human: "human";
+        }>>>;
+        appliesTo: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+          surface: "surface";
+          workpiece: "workpiece";
+          artifact: "artifact";
+        }>>>;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }; /** Emitted when a facet namespace registration is added or updated. */
+  'namespace.changed': z.ZodObject<{
+    namespace: z.ZodString;
+  }, z.core.$strip>;
+}>;
+/**
+ * Typed subjects for facet bus communication.
+ *
+ * Available subjects:
+ * - `FacetSubjects['namespace.register']` — register a facet namespace (RPC)
+ * - `FacetSubjects['namespace.list']` — list facet namespaces (RPC)
+ * - `FacetSubjects['namespace.changed']` — facet namespace changed event
+ *
+ * Nested shorthand (via dot-segment nesting):
+ * - `FacetSubjects.namespace.register` — register (RPC)
+ * - `FacetSubjects.namespace.list` — list (RPC)
+ * - `FacetSubjects.namespace.changed` — changed event
+ */
+declare const FacetSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"facet", {
+  /**
+   * Register a new facet namespace with the facet service (RPC).
+   * Returns `{ registered: true }` when successfully stored.
+   */
+  'namespace.register': {
+    request: z.ZodObject<{
+      namespace: z.ZodString;
+      cardinality: z.ZodEnum<{
+        single: "single";
+        multiple: "multiple";
+      }>;
+      values: z.ZodUnion<readonly [z.ZodLiteral<"open">, z.ZodReadonly<z.ZodArray<z.ZodString>>]>;
+      authority: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        agent: "agent";
+        system: "system";
+        human: "human";
+      }>>>;
+      appliesTo: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        surface: "surface";
+        workpiece: "workpiece";
+        artifact: "artifact";
+      }>>>;
+      description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      registered: z.ZodBoolean;
+    }, z.core.$strip>;
+  }; /** List registered facet namespaces, optionally filtered by namespace string (RPC). */
+  'namespace.list': {
+    request: z.ZodObject<{
+      namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      namespaces: z.ZodArray<z.ZodObject<{
+        namespace: z.ZodString;
+        cardinality: z.ZodEnum<{
+          single: "single";
+          multiple: "multiple";
+        }>;
+        values: z.ZodUnion<readonly [z.ZodLiteral<"open">, z.ZodReadonly<z.ZodArray<z.ZodString>>]>;
+        authority: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+          agent: "agent";
+          system: "system";
+          human: "human";
+        }>>>;
+        appliesTo: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+          surface: "surface";
+          workpiece: "workpiece";
+          artifact: "artifact";
+        }>>>;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }; /** Emitted when a facet namespace registration is added or updated. */
+  'namespace.changed': z.ZodObject<{
+    namespace: z.ZodString;
+  }, z.core.$strip>;
+}>, "facet">;
+/** Request payload for registering a facet namespace. */
+type FacetNamespaceRegisterRequest = z.infer<(typeof FacetSchemas)['namespace.register']['request']>;
+/** Response payload for registering a facet namespace. */
+type FacetNamespaceRegisterResponse = z.infer<(typeof FacetSchemas)['namespace.register']['response']>;
+/** Request payload for listing facet namespaces. */
+type FacetNamespaceListRequest = z.infer<(typeof FacetSchemas)['namespace.list']['request']>;
+/** Response payload for listing facet namespaces. */
+type FacetNamespaceListResponse = z.infer<(typeof FacetSchemas)['namespace.list']['response']>;
+/** Payload for the facet namespace changed event. */
+type FacetNamespaceChangedPayload = z.infer<(typeof FacetSchemas)['namespace.changed']>;
+//#endregion
+export { FacetNamespaceRegistration as _, FacetNamespaceRegisterRequest as a, FacetSubjects as c, FacetAppliesTo as d, FacetAppliesToSchema as f, FacetCardinalitySchema as g, FacetCardinality as h, FacetNamespaceListResponse as i, FacetNamespaceDefinition as l, FacetAuthoritySchema as m, FacetNamespaceChangedPayload as n, FacetNamespaceRegisterResponse as o, FacetAuthority as p, FacetNamespaceListRequest as r, FacetSchemas as s, FacetNamespace as t, defineFacetNamespace as u, FacetNamespaceRegistrationSchema as v };