@lssm/lib.contracts 1.2.0

package/README.md

@@ -0,0 +1,361 @@
+## @lssm/lib.contracts — Unified Specs for Ops, Events, Presentations, and Features
+
+Purpose: Provide a single, typed source of truth for backend operations, events, prompts/resources, and UI/data presentations. This enables consistent adapters (REST/GraphQL/MCP/UI), high‑quality docs, and agent-friendly automation across apps.
+
+### Installation
+
+```bash
+npm install @lssm/lib.contracts @lssm/lib.schema
+# or
+bun add @lssm/lib.contracts @lssm/lib.schema
+```
+
+Import from the scoped entry points for leaner bundles:
+
+- `@lssm/lib.contracts/client` – browser-safe helpers (`client/react`, render drivers, SDK).
+- `@lssm/lib.contracts/server` – Node adapters (REST, GraphQL, MCP).
+- `@lssm/lib.contracts/types` – runtime context types (`HandlerCtx`, `PolicyDecision`, etc.).
+- `@lssm/lib.contracts/types/all` – type-only re-exports across the package (compiles to an empty JS module).
+
+### Today (already implemented)
+
+- **Operations (ContractSpec)**: versioned `command`/`query` definitions with `meta`, `io` (zod-backed via `@lssm/lib.schema`), `policy`, `sideEffects` (declared events), `transport` hints, and `acceptance` examples. See `src/spec.ts` and `src/registry.ts`.
+- **Events (EventSpec)**: versioned event payloads validated at publish time and guarded from undeclared emission. See `src/events.ts` and runtime guard in `SpecRegistry.execute()`.
+- **Adapters**:
+  - REST: `server/rest-generic`, `server/rest-next-app`, `server/rest-next-pages`, `server/rest-elysia`.
+  - MCP: `server/provider-mcp` (tools, resources, prompts), `server/rest-next-mcp` (MCP via Next route).
+  - GraphQL: `server/graphql-pothos` to mount contract operations into a Pothos schema.
+  - Docs: `markdown.specsToMarkdown(reg)` and `markdown.docsToMarkdown(reg, { presentations, features })` to render human docs.
+
+### Next (this document proposes)
+
+Add a first-class, typed presentation layer (V2 descriptors available today) and feature grouping so one module can declare:
+
+- What it DOES (operations/queries),
+- What it EMITS (events),
+- How it is SHOWN or EXPORTED (presentations),
+- How to INSTALL/REGISTER it as a coherent feature.
+
+This improves reuse, observability, and AI agent operability across web apps, docs, and integrations.
+
+---
+
+## Presentation Categories
+
+Three complementary presentation types can be declared and exported from the contracts library. They are transport-agnostic and do not bind to a specific app; host apps mount them using adapters. A normalized V2 descriptor exists in `presentations.v2.ts` with a transform engine and validators.
+
+### 1) Web components (React first)
+
+- **Goal**: Render real user stories with clean, simple, Atomic Design components. Mobile-friendly by default.
+- **Adapter**: Host app provides a `componentMap` that resolves a `componentKey` to a concrete React component. This avoids cross-package JSX coupling.
+- **Use cases**: Feature previews, onboarding stories, guided flows.
+
+Shape (proposed):
+
+```ts
+type PresentationKind = 'web_component' | 'markdown' | 'data';
+
+interface PresentationMeta {
+  name: string; // e.g. "hcircle.weekly_pulse.quick_vote"
+  version: number; // bump on breaking changes
+  stability?: 'experimental' | 'beta' | 'stable' | 'deprecated';
+  owners?: string[];
+  tags?: string[]; // search, grouping
+  description?: string;
+}
+
+interface WebComponentPresentation {
+  kind: 'web_component';
+  framework: 'react';
+  /** Symbolic key resolved by host via componentMap */
+  componentKey: string; // e.g. "userStory.weekly_pulse.quick_vote"
+  /** zod-backed props schema from @lssm/lib.schema */
+  props: import('@lssm/lib.schema').AnySchemaModel;
+  /** Optional interaction analytics intents */
+  analytics?: string[];
+}
+```
+
+Host-side rendering contract (example):
+
+```ts
+// In the host app
+const componentMap: Record<string, React.ComponentType<any>> = {
+  'userStory.weekly_pulse.quick_vote': QuickVote,
+  'userStory.weekly_pulse.happiness': HappinessLife,
+};
+
+function renderWebPresentation(p: WebComponentPresentation, data: any) {
+  const C = componentMap[p.componentKey];
+  if (!C) return <Fallback componentKey={p.componentKey} />;
+  const parsed = p.props.getZod().parse(data);
+  return <C {...parsed} />;
+}
+```
+
+Guidelines:
+
+- Use Atomic Design; keep components stateless where feasible.
+- Ensure a11y (labels, roles, keyboard traversal) and small-screen ergonomics.
+- Gate feature-flagged experiences in the host, aligning with `policy.flags` when relevant.
+
+### 2) Markdown/MDX
+
+- **Goal**: Make the platform and its features easily digestible by LLMs and human readers.
+- **Adapter**: Expose as static strings (Markdown) or MDX sources. Optionally resolve via `ResourceRegistry` URIs so MCP clients can fetch them.
+- **Use cases**: Feature guides, acceptance narratives, inline help.
+
+Shape (proposed):
+
+```ts
+interface MarkdownPresentation {
+  kind: 'markdown';
+  /** Either inline content or a resource URI template */
+  content?: string; // Markdown/MDX source
+  resourceUri?: string; // e.g. "feature://{featureKey}/story/{storyKey}.md"
+}
+```
+
+### 3) Structured raw data (JSON/XML)
+
+- **Goal**: Enable external integrations, partial adoption, and customized setups without lock-in.
+- **Adapter**: Expose via `ResourceRegistry` with stable URIs and MIME types; MCP resources map 1:1.
+- **Use cases**: CSV/JSON/XML export, analytics snapshots, reference dictionaries.
+
+Shape (proposed):
+
+```ts
+interface DataPresentation {
+  kind: 'data';
+  mimeType: 'application/json' | 'application/xml' | string;
+  /** zod-backed schema for the payload structure */
+  model: import('@lssm/lib.schema').AnySchemaModel;
+}
+```
+
+Union and registry (proposed):
+
+```ts
+type PresentationSpec = {
+  meta: PresentationMeta;
+  policy?: { flags?: string[]; pii?: string[] };
+  content: WebComponentPresentation | MarkdownPresentation | DataPresentation;
+};
+
+class PresentationRegistry {
+  register(p: PresentationSpec): this {
+    /* ... */ return this;
+  }
+  list(): PresentationSpec[] {
+    /* ... */ return [];
+  }
+  get(name: string, version?: number): PresentationSpec | undefined {
+    /* ... */ return undefined;
+  }
+}
+```
+
+---
+
+## Feature Grouping
+
+Group operations, events, and presentations into a feature/module spec that can be installed in one go.
+
+Shape (proposed):
+
+```ts
+interface FeatureModuleMeta {
+  key: string; // stable slug, e.g. "weekly_pulse"
+  title: string;
+  description?: string;
+  domain?: string; // bounded context, e.g. "hcircle.harmony"
+  owners?: string[];
+  tags?: string[]; // e.g. ["connect", "save_time"]
+}
+
+interface FeatureModuleSpec {
+  meta: FeatureModuleMeta;
+  operations?: Array<{ name: string; version: number }>; // ContractSpec
+  events?: Array<{ name: string; version: number }>; // EventSpec
+  presentations?: Array<{ name: string; version: number }>; // PresentationSpec
+}
+
+class FeatureRegistry {
+  register(f: FeatureModuleSpec): this {
+    /* ... */ return this;
+  }
+  list(): FeatureModuleSpec[] {
+    /* ... */ return [];
+  }
+}
+
+// Optional installer to wire everything in one call
+function installFeature(
+  feature: FeatureModuleSpec,
+  deps: {
+    ops: import('./src/registry').SpecRegistry;
+    presentations: PresentationRegistry;
+    resources: import('./src/resources').ResourceRegistry;
+  }
+) {
+  /* register ops/events/presentations/resources */
+}
+```
+
+Why group?
+
+- Single place to discover/enable a capability
+- Consistent docs generation and MCP exposure
+- Better alignment with product modules (see `hcircle` module registry)
+
+---
+
+## Mapping coliving modules → Presentations
+
+Reference: `packages/hcircle/apps/web-coliving/src/components/modules/{types.ts,registry.ts}` defines modules like `weekly_pulse`, `incident_hygiene`, `groceries`, with user stories and preview components.
+
+Examples (conceptual):
+
+```ts
+// Web component presentations (user stories)
+const WeeklyPulseQuickVote: PresentationSpec = {
+  meta: {
+    name: 'hcircle.weekly_pulse.quick_vote',
+    version: 1,
+    tags: ['connect', 'harmony'],
+    description: '3-tap check-in for house alignment',
+  },
+  content: {
+    kind: 'web_component',
+    framework: 'react',
+    componentKey: 'userStory.weekly_pulse.quick_vote',
+    props: /* SchemaModel for props */ undefined as any,
+  },
+};
+
+// Markdown/MDX guide
+const WeeklyPulseGuide: PresentationSpec = {
+  meta: { name: 'hcircle.weekly_pulse.guide', version: 1 },
+  content: {
+    kind: 'markdown',
+    resourceUri: 'feature://weekly_pulse/story/guide.md',
+  },
+};
+
+// Data export (JSON)
+const GroceriesBudgetExport: PresentationSpec = {
+  meta: { name: 'hcircle.groceries.budget_export', version: 1 },
+  content: {
+    kind: 'data',
+    mimeType: 'application/json',
+    model: /* SchemaModel for export shape */ undefined as any,
+  },
+};
+```
+
+In the feature group:
+
+```ts
+const WeeklyPulseFeature: FeatureModuleSpec = {
+  meta: {
+    key: 'weekly_pulse',
+    title: 'Weekly Pulse',
+    tags: ['harmony', 'connect'],
+  },
+  operations: [{ name: 'pulse.submitQuickVote', version: 1 }],
+  events: [{ name: 'pulse.vote_recorded', version: 1 }],
+  presentations: [
+    { name: 'hcircle.weekly_pulse.quick_vote', version: 1 },
+    { name: 'hcircle.weekly_pulse.guide', version: 1 },
+  ],
+};
+```
+
+---
+
+## Adapters and Exposure
+
+- **REST**: already provided; driven by `SpecRegistry`. Presentations are not REST endpoints directly, but their data forms can be exposed as `ResourceRegistry` entries.
+- **GraphQL (Pothos)**: provided in `src/server/graphql-pothos.ts`. Auto-maps operations into Query/Mutation fields. Presentations are better exposed as resources (URIs) consumed by prompts/LLMs.
+- **MCP**: `createMcpServer` exposes commands (tools), resources, and prompts. Presentations map naturally:
+  - `web_component` → discoverable metadata (name, tags) for UI agents.
+  - `markdown` → resources (URIs) returned by prompts.
+  - `data` → resources with explicit MIME types.
+- **Docs**: extend `specsToMarkdown` to include presentations and feature groups so dev portals stay in sync. See `docs/tech/contracts/presentations-v2.md` for the unified V2 model and engine.
+
+---
+
+## Versioning & Stability (recommended)
+
+- Bump `version` on any breaking change to shape or behavior of the spec.
+- Mark `stability` to guide adopters: `experimental` → `beta` → `stable` → `deprecated`.
+- Keep event payloads and data exports backward compatible where feasible. For UI, prefer additive props; otherwise, bump version and keep both entries during transition.
+
+---
+
+## Adapters Planning (next steps)
+
+- React adapter: resolve `componentKey` → component map in host, validate props with SchemaModel, capture analytics intents.
+- Markdown adapter: expose `markdown` presentations via `ResourceRegistry` + MCP resources; optionally render in app help.
+- Data adapter: expose `data` presentations via `ResourceRegistry` with explicit MIME types (JSON/XML) and stable URIs.
+
+---
+
+## Authoring Guidelines
+
+- **Atomic Design** for web components; keep complexity low and interactions obvious.
+- **Accessibility**: labels, roles, focus order, and reduced motion options.
+- **i18n**: UI strings belong in app i18n namespaces; contracts carry keys and defaults, not hard-coded text.
+- **Feature flags**: gate risky or staged presentations via `policy.flags` + host checks.
+- **Docs as source**: when specs change, update `docs/` in the same change.
+
+---
+
+## How to Add a New Feature
+
+1. Define operations/events in code using `defineCommand`, `defineQuery`, and `defineEvent`.
+2. Declare presentations (at least one) in a `PresentationRegistry` and link to the feature.
+3. Register a `FeatureModuleSpec` that references ops/events/presentations.
+4. Mount adapters in the host app(s): REST/GraphQL/MCP/UI.
+5. Update docs via the markdown generator and/or bespoke docs in `docs/`.
+
+### Quick start
+
+```ts
+import { SpecRegistry, installOp } from '@lssm/lib.contracts';
+import { makeNextAppHandler } from '@lssm/lib.contracts/server/rest-next-app';
+
+const reg = new SpecRegistry();
+installOp(reg, BeginSignupSpec, beginSignupHandler);
+
+export const { GET, POST } = {
+  GET: (req: Request) =>
+    makeNextAppHandler(reg, () => ({ actor: 'anonymous' }))(req),
+  POST: (req: Request) =>
+    makeNextAppHandler(reg, () => ({ actor: 'anonymous' }))(req),
+};
+```
+
+---
+
+## Exports (current)
+
+See `src/index.ts` for public exports:
+
+- Ops/events/specs/registries
+- REST/Next/Elysia/MCP adapters
+- Markdown generator, prompt registry, resources
+
+Planned additions:
+
+- `PresentationSpec`, `PresentationRegistry`
+- `FeatureModuleSpec`, `FeatureRegistry`, `installFeature`
+- Extended docs generator to include presentations/features
+
+---
+
+## Notes
+
+- Keep adapters and registries modular and swappable (hexagonal). Domain logic must remain testable in isolation.
+- Prefer `@lssm/lib.schema` models to avoid zod schema drift across adapters.
+- When multiple apps consume the same presentation, rely on the `componentKey` indirection rather than importing components across packages.

package/dist/app-config/branding.d.ts

@@ -0,0 +1,56 @@
+//#region src/app-config/branding.d.ts
+interface BrandingAssetRef {
+  type: 'logo' | 'logo-dark' | 'favicon' | 'og-image';
+  url?: string;
+  dimensions?: {
+    width: number;
+    height: number;
+  };
+}
+interface BrandingDefaults {
+  appNameKey: string;
+  assets?: BrandingAssetRef[];
+  colorTokens?: {
+    primary?: string;
+    secondary?: string;
+  };
+}
+interface TenantBrandingAsset {
+  type: 'logo' | 'logo-dark' | 'favicon' | 'og-image';
+  url: string;
+  metadata?: {
+    mimeType?: string;
+    sizeBytes?: number;
+    dimensions?: {
+      width: number;
+      height: number;
+    };
+  };
+}
+interface TenantBrandingConfig {
+  appName?: Record<string, string>;
+  assets?: TenantBrandingAsset[];
+  colors?: {
+    primary?: string;
+    secondary?: string;
+  };
+  customDomain?: string;
+  subdomain?: string;
+}
+interface ResolvedBranding {
+  appName: string;
+  assets: {
+    logo?: string;
+    logoDark?: string;
+    favicon?: string;
+    ogImage?: string;
+  };
+  colors: {
+    primary: string;
+    secondary: string;
+  };
+  domain: string;
+}
+//#endregion
+export { BrandingAssetRef, BrandingDefaults, ResolvedBranding, TenantBrandingAsset, TenantBrandingConfig };
+//# sourceMappingURL=branding.d.ts.map

package/dist/app-config/branding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branding.d.ts","names":[],"sources":["../../src/app-config/branding.ts"],"sourcesContent":[],"mappings":";UAAiB,gBAAA;EAAA,IAAA,EAAA,MAAA,GAAA,WAAgB,GAAA,SAAA,GAAA,UAAA;EAMhB,GAAA,CAAA,EAAA,MAAA;EASA,UAAA,CAAA,EAAA;IAUA,KAAA,EAAA,MAAA;IAWA,MAAA,EAAA,MAAA;;;UA9BA,gBAAA;;WAEN;;;;;;UAOM,mBAAA;;;;;;;;;;;;UAUA,oBAAA;YACL;WACD;;;;;;;;UASM,gBAAA"}

package/dist/app-config/contracts.d.ts

@@ -0,0 +1,243 @@
+import { ContractSpec } from "../spec.js";
+import { SpecRegistry } from "../registry.js";
+
+//#region src/app-config/contracts.d.ts
+declare const UpdateTenantBrandingCommand: ContractSpec<SchemaModel<{
+  tenantId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  appId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  environment: {
+    type: void 0<string, string>;
+    isOptional: true;
+  };
+  appName: {
+    type: void 0<Record<string, unknown>, Record<string, unknown>>;
+    isOptional: true;
+  };
+  assets: {
+    type: SchemaModel<{
+      type: {
+        type: void 0<string, string>;
+        isOptional: false;
+      };
+      url: {
+        type: void 0<string, string>;
+        isOptional: false;
+      };
+      mimeType: {
+        type: void 0<string, string>;
+        isOptional: true;
+      };
+    }>;
+    isOptional: true;
+    isArray: true;
+  };
+  colors: {
+    type: void 0<Record<string, unknown>, Record<string, unknown>>;
+    isOptional: true;
+  };
+  customDomain: {
+    type: void 0<string, string>;
+    isOptional: true;
+  };
+  subdomain: {
+    type: void 0<string, string>;
+    isOptional: true;
+  };
+}>, SchemaModel<{
+  success: {
+    type: void 0<boolean, boolean>;
+    isOptional: false;
+  };
+  updatedAt: {
+    type: void 0<Date, string>;
+    isOptional: false;
+  };
+}>, undefined>;
+declare const VerifyCustomDomainCommand: ContractSpec<SchemaModel<{
+  tenantId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  appId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  domain: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+}>, SchemaModel<{
+  status: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  message: {
+    type: void 0<string, string>;
+    isOptional: true;
+  };
+}>, undefined>;
+declare const UpdateBlueprintTranslationCatalogCommand: ContractSpec<SchemaModel<{
+  blueprintName: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  blueprintVersion: {
+    type: void 0<number, number>;
+    isOptional: false;
+  };
+  catalogName: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  catalogVersion: {
+    type: void 0<number, number>;
+    isOptional: false;
+  };
+  defaultLocale: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  supportedLocales: {
+    type: void 0<string, string>;
+    isOptional: false;
+    isArray: true;
+  };
+  entries: {
+    type: SchemaModel<{
+      key: {
+        type: void 0<string, string>;
+        isOptional: false;
+      };
+      locale: {
+        type: void 0<string, string>;
+        isOptional: false;
+      };
+      value: {
+        type: void 0<string, string>;
+        isOptional: false;
+      };
+      context: {
+        type: void 0<string, string>;
+        isOptional: true;
+      };
+    }>;
+    isOptional: false;
+    isArray: true;
+  };
+}>, SchemaModel<{
+  success: {
+    type: void 0<boolean, boolean>;
+    isOptional: false;
+  };
+  updatedAt: {
+    type: void 0<Date, string>;
+    isOptional: false;
+  };
+}>, undefined>;
+declare const UpdateTenantTranslationOverridesCommand: ContractSpec<SchemaModel<{
+  tenantId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  appId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  entries: {
+    type: SchemaModel<{
+      key: {
+        type: void 0<string, string>;
+        isOptional: false;
+      };
+      locale: {
+        type: void 0<string, string>;
+        isOptional: false;
+      };
+      value: {
+        type: void 0<string, string>;
+        isOptional: false;
+      };
+      context: {
+        type: void 0<string, string>;
+        isOptional: true;
+      };
+    }>;
+    isOptional: false;
+    isArray: true;
+  };
+  defaultLocale: {
+    type: void 0<string, string>;
+    isOptional: true;
+  };
+  enabledLocales: {
+    type: void 0<string, string>;
+    isOptional: true;
+    isArray: true;
+  };
+}>, SchemaModel<{
+  success: {
+    type: void 0<boolean, boolean>;
+    isOptional: false;
+  };
+  updatedAt: {
+    type: void 0<Date, string>;
+    isOptional: false;
+  };
+}>, undefined>;
+declare const GetResolvedBrandingQuery: ContractSpec<SchemaModel<{
+  tenantId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  appId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  environment: {
+    type: void 0<string, string>;
+    isOptional: true;
+  };
+}>, SchemaModel<{
+  branding: {
+    type: void 0<Record<string, unknown>, Record<string, unknown>>;
+    isOptional: false;
+  };
+}>, undefined>;
+declare const ResolveMessageQuery: ContractSpec<SchemaModel<{
+  tenantId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  appId: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  locale: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+  key: {
+    type: void 0<string, string>;
+    isOptional: false;
+  };
+}>, SchemaModel<{
+  value: {
+    type: void 0<string, string>;
+    isOptional: true;
+  };
+  source: {
+    type: void 0<string, string>;
+    isOptional: true;
+  };
+}>, undefined>;
+declare const appConfigContracts: Record<string, ContractSpec<any, any>>;
+declare function registerAppConfigContracts(registry: SpecRegistry): SpecRegistry;
+//#endregion
+export { GetResolvedBrandingQuery, ResolveMessageQuery, UpdateBlueprintTranslationCatalogCommand, UpdateTenantBrandingCommand, UpdateTenantTranslationOverridesCommand, VerifyCustomDomainCommand, appConfigContracts, registerAppConfigContracts };
+//# sourceMappingURL=contracts.d.ts.map

package/dist/app-config/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","names":[],"sources":["../../src/app-config/contracts.ts"],"sourcesContent":[],"mappings":";;;;cAgIa,6BAA2B,aAAA;EAA3B,QAAA,EAAA;IAoBX,IAAA,EAAA,KAAA,CAAA,CAAA,MAAA,EAAA,MAAA,CAAA;;;;;;;;;;;;;;;EApBsC,MAAA,EAAA;IAAA,IAAA,aAAA,CAAA;;;;MAAA,CAAA;MAAA,GAAA,EAAA;QAsB3B,IAAA,QAoBX,CAAA,MAAA,EAAA,MAAA,CAAA;QAAA,UAAA,EAAA,KAAA;;;QApBoC,IAAA,QAAA,CAAA,MAAA,EAAA,MAAA,CAAA;QAAA,UAAA,EAAA,IAAA;;;IAAA,UAAA,EAAA,IAAA;IAAA,OAAA,EAAA,IAAA;EAsBzB,CAAA;EAoBX,MAAA,EAAA;;;;;;;;;;;EApBmD,CAAA;CAAA,CAAA,aAAA,CAAA;;UA5Cb,KAAA;;EA4Ca,CAAA;EAAA,SAAA,EAAA;IAsBxC,IAAA,QAoBX,KAAA,EAAA,MAAA,CAAA;IAAA,UAAA,EAAA,KAAA;;;cAhEW,2BAAyB,aAAA;;UAoBpC,KAAA;;;;IAwBkD,IAAA,QAAA,CAAA,MAAA,EAAA,MAAA,CAAA;IAAA,UAAA,EAAA,KAAA;;;;IAAA,UAAA,EAAA,KAAA;EAAA,CAAA;AAsBpD,CAAA,CAAA,aAAa,CAAA;EAgCX,MAAA,EAAA;UAlGoC,KAAA;;EAkED,CAAA;;;;;CAAA,CAAA,EAAA,SAAA,CAAA;AAAA,cA5CxB,wCA4CwB,EA5CgB,YA4ChB,CA5CgB,WA4ChB,CAAA;EAkCxB,aAAA,EAAA;IAqBX,IAAA,EA/EA,KAAA,CA+EA,CAAA,MAAA,EAAA,MAAA,CAAA;;;;IArB8B,IAAA,QAAA,CAAA,MAAA,EAAA,MAAA,CAAA;IAAA,UAAA,EAAA,KAAA;;;IAAA,IAAA,QAAA,CAAA,MAAA,EAAA,MAAA,CAAA;IAAA,UAAA,EAAA,KAAA;EAuBnB,CAAA;EASG,cAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA9GqC,KAAA;;;;;;;;cAsBxC,yCAAuC,aAAA;;UAoBlD,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UApBkD,KAAA;;;;;;;;cAsBvC,0BAAwB,aAAA;;UAgCnC,KAAA;;;;;;;;;;;;;;;;;cAEW,qBAAmB,aAAA;;UAqB9B,KAAA;;;;;;;;;;;;;;;;;UArB8B,KAAA;;;;;;;;cAuBnB,oBAAoB,eAAe;iBAShC,0BAAA,WAAqC,eAAY"}

package/dist/app-config/contracts.js

@@ -0,0 +1,2 @@
+import{ScalarTypeEnum as e}from"../schema/src/ScalarTypeEnum.js";import{SchemaModel as t}from"../schema/src/SchemaModel.js";import"../schema/src/index.js";import{defineCommand as n,defineQuery as r}from"../spec.js";import{OwnersEnum as i,StabilityEnum as a,TagsEnum as o}from"../ownership.js";const s=new t({name:`BrandingAssetInput`,fields:{type:{type:e.String_unsecure(),isOptional:!1},url:{type:e.URL(),isOptional:!1},mimeType:{type:e.String_unsecure(),isOptional:!0}}}),c=new t({name:`UpdateTenantBrandingInput`,fields:{tenantId:{type:e.ID(),isOptional:!1},appId:{type:e.ID(),isOptional:!1},environment:{type:e.String_unsecure(),isOptional:!0},appName:{type:e.JSONObject(),isOptional:!0},assets:{type:s,isOptional:!0,isArray:!0},colors:{type:e.JSONObject(),isOptional:!0},customDomain:{type:e.String_unsecure(),isOptional:!0},subdomain:{type:e.String_unsecure(),isOptional:!0}}}),l=new t({name:`UpdateTenantBrandingOutput`,fields:{success:{type:e.Boolean(),isOptional:!1},updatedAt:{type:e.DateTime(),isOptional:!1}}}),u=new t({name:`VerifyCustomDomainInput`,fields:{tenantId:{type:e.ID(),isOptional:!1},appId:{type:e.ID(),isOptional:!1},domain:{type:e.String_unsecure(),isOptional:!1}}}),d=new t({name:`VerifyCustomDomainOutput`,fields:{status:{type:e.String_unsecure(),isOptional:!1},message:{type:e.String_unsecure(),isOptional:!0}}}),f=new t({name:`TranslationEntryInput`,fields:{key:{type:e.String_unsecure(),isOptional:!1},locale:{type:e.String_unsecure(),isOptional:!1},value:{type:e.String_unsecure(),isOptional:!1},context:{type:e.String_unsecure(),isOptional:!0}}}),p=new t({name:`UpdateBlueprintTranslationInput`,fields:{blueprintName:{type:e.String_unsecure(),isOptional:!1},blueprintVersion:{type:e.Int_unsecure(),isOptional:!1},catalogName:{type:e.String_unsecure(),isOptional:!1},catalogVersion:{type:e.Int_unsecure(),isOptional:!1},defaultLocale:{type:e.String_unsecure(),isOptional:!1},supportedLocales:{type:e.String_unsecure(),isOptional:!1,isArray:!0},entries:{type:f,isOptional:!1,isArray:!0}}}),m=new t({name:`UpdateTenantTranslationInput`,fields:{tenantId:{type:e.ID(),isOptional:!1},appId:{type:e.ID(),isOptional:!1},entries:{type:f,isOptional:!1,isArray:!0},defaultLocale:{type:e.String_unsecure(),isOptional:!0},enabledLocales:{type:e.String_unsecure(),isOptional:!0,isArray:!0}}}),h=new t({name:`MessageResolutionInput`,fields:{tenantId:{type:e.ID(),isOptional:!1},appId:{type:e.ID(),isOptional:!1},locale:{type:e.String_unsecure(),isOptional:!1},key:{type:e.String_unsecure(),isOptional:!1}}}),g=new t({name:`MessageResolutionOutput`,fields:{value:{type:e.String_unsecure(),isOptional:!0},source:{type:e.String_unsecure(),isOptional:!0}}}),_=n({meta:{name:`appConfig.updateTenantBranding`,version:1,description:`Applies tenant branding overrides (names, assets, domains).`,owners:[i.PlatformSigil],tags:[`branding`],stability:a.Beta,goal:`Maintain tenant-specific branding assets and domains.`,context:`Invoked by the Studio or automation when a tenant updates branding settings.`},io:{input:c,output:l},policy:{auth:`admin`,policies:[{name:`platform.app-config.manage`,version:1}]}}),v=n({meta:{name:`appConfig.verifyCustomDomain`,version:1,description:`Validates DNS ownership for tenant custom domains.`,owners:[i.PlatformSigil],tags:[`branding`],stability:a.Experimental,goal:`Confirm tenant-provided domains before activation.`,context:`Triggered after the tenant adds DNS records to verify domain ownership.`},io:{input:u,output:d},policy:{auth:`admin`,policies:[{name:`platform.app-config.manage`,version:1}]}}),y=n({meta:{name:`appConfig.updateBlueprintTranslationCatalog`,version:1,description:`Registers or updates translation entries for a blueprint.`,owners:[i.PlatformSigil],tags:[o.I18n],stability:a.Beta,goal:`Keep blueprint translation catalogs in sync with shipped copy.`,context:`Executed by platform automation or CI when committing updated translation catalogs.`},io:{input:p,output:l},policy:{auth:`admin`,policies:[{name:`platform.app-config.manage`,version:1}]}}),b=n({meta:{name:`appConfig.updateTenantTranslations`,version:1,description:`Applies tenant-specific translation entries.`,owners:[i.PlatformSigil],tags:[o.I18n],stability:a.Beta,goal:`Allow tenants to override selected message keys.`,context:`Called by the Studio when a tenant customizes labels or copy for their locale.`},io:{input:m,output:l},policy:{auth:`admin`,policies:[{name:`platform.app-config.manage`,version:1}]}}),x=r({meta:{name:`appConfig.getResolvedBranding`,version:1,description:`Returns the resolved branding for a tenant/app/environment.`,owners:[i.PlatformSigil],tags:[`branding`],stability:a.Beta,goal:`Expose hydrated branding assets for rendering UI/email experiences.`,context:`Used by runtime surfaces to fetch brand assets prior to rendering tenant-specific experiences.`},io:{input:new t({name:`GetResolvedBrandingInput`,fields:{tenantId:{type:e.ID(),isOptional:!1},appId:{type:e.ID(),isOptional:!1},environment:{type:e.String_unsecure(),isOptional:!0}}}),output:new t({name:`GetResolvedBrandingOutput`,fields:{branding:{type:e.JSONObject(),isOptional:!1}}})},policy:{auth:`admin`,policies:[{name:`platform.app-config.read`,version:1}]}}),S=r({meta:{name:`appConfig.resolveMessage`,version:1,description:`Resolves a translation key for a tenant in the requested locale.`,owners:[i.PlatformSigil],tags:[o.I18n],stability:a.Experimental,goal:`Expose a server-side API for resolving message keys on demand.`,context:`Used by backend services or scripts that need translated copy outside the front-end runtime.`},io:{input:h,output:g},policy:{auth:`admin`,policies:[{name:`platform.app-config.read`,version:1}]}}),C={UpdateTenantBrandingCommand:_,VerifyCustomDomainCommand:v,UpdateBlueprintTranslationCatalogCommand:y,UpdateTenantTranslationOverridesCommand:b,GetResolvedBrandingQuery:x,ResolveMessageQuery:S};function w(e){return e.register(_).register(v).register(y).register(b).register(x).register(S)}export{x as GetResolvedBrandingQuery,S as ResolveMessageQuery,y as UpdateBlueprintTranslationCatalogCommand,_ as UpdateTenantBrandingCommand,b as UpdateTenantTranslationOverridesCommand,v as VerifyCustomDomainCommand,C as appConfigContracts,w as registerAppConfigContracts};
+//# sourceMappingURL=contracts.js.map