@lssm/lib.contracts 0.0.0-canary-20251217052941 → 0.0.0-canary-20251217060433

package/dist/markdown.d.ts

@@ -0,0 +1,21 @@
+import { PresentationRegistry } from "./presentations.js";
+import { SpecRegistry } from "./registry.js";
+import { FeatureRegistry } from "./features.js";
+
+//#region src/markdown.d.ts
+
+/**
+ * Render simple Markdown docs for each spec.
+ * Useful for dev portals and repo docs generation.
+ */
+declare function specsToMarkdown(reg: SpecRegistry, extras?: {
+  presentations?: PresentationRegistry;
+  features?: FeatureRegistry;
+}): string;
+/** Render presentations and features as additional sections. */
+declare function docsToMarkdown(reg: SpecRegistry, extras: {
+  presentations?: PresentationRegistry;
+  features?: FeatureRegistry;
+}): string;
+//#endregion
+export { docsToMarkdown, specsToMarkdown };

package/dist/migrations.d.ts

@@ -0,0 +1,52 @@
+import { OwnerShipMeta } from "./ownership.js";
+
+//#region src/migrations.d.ts
+type MigrationStepKind = 'schema' | 'data' | 'validation';
+interface MigrationCheck {
+  description: string;
+  expression: string;
+}
+interface MigrationStepBase {
+  kind: MigrationStepKind;
+  description?: string;
+  timeoutMs?: number;
+  retries?: number;
+  preChecks?: MigrationCheck[];
+  postChecks?: MigrationCheck[];
+}
+interface SchemaMigrationStep extends MigrationStepBase {
+  kind: 'schema';
+  sql: string;
+}
+interface DataMigrationStep extends MigrationStepBase {
+  kind: 'data';
+  script: string;
+}
+interface ValidationMigrationStep extends MigrationStepBase {
+  kind: 'validation';
+  assertion: string;
+}
+type MigrationStep = SchemaMigrationStep | DataMigrationStep | ValidationMigrationStep;
+interface MigrationMeta extends OwnerShipMeta {
+  /** Fully qualified migration name (e.g., "sigil.db.2025_01_add_users"). */
+  name: string;
+  /** Increment when the migration changes. */
+  version: number;
+}
+interface MigrationPlan {
+  up: MigrationStep[];
+  down?: MigrationStep[];
+}
+interface MigrationSpec {
+  meta: MigrationMeta;
+  plan: MigrationPlan;
+  dependencies?: string[];
+}
+declare class MigrationRegistry {
+  private readonly items;
+  register(spec: MigrationSpec): this;
+  list(): MigrationSpec[];
+  get(name: string, version?: number): MigrationSpec | undefined;
+}
+//#endregion
+export { DataMigrationStep, MigrationCheck, MigrationMeta, MigrationPlan, MigrationRegistry, MigrationSpec, MigrationStep, MigrationStepBase, MigrationStepKind, SchemaMigrationStep, ValidationMigrationStep };

package/dist/onboarding-base.d.ts

@@ -0,0 +1,137 @@
+import { ContractSpec } from "./spec.js";
+import * as _lssm_lib_schema7 from "@lssm/lib.schema";
+import { SchemaModel } from "@lssm/lib.schema";
+
+//#region src/onboarding-base.d.ts
+/** Save/update onboarding draft (auto-save during flow) */
+declare const SaveOnboardingDraftInput: SchemaModel<{
+  data: {
+    type: _lssm_lib_schema7.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+}>;
+declare const SaveOnboardingDraftOutput: SchemaModel<{
+  id: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: false;
+  };
+  organizationId: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: false;
+  };
+}>;
+declare const SaveOnboardingDraftBaseSpec: ContractSpec<SchemaModel<{
+  data: {
+    type: _lssm_lib_schema7.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+}>, SchemaModel<{
+  id: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: false;
+  };
+  organizationId: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: false;
+  };
+}>, undefined>;
+/** Get current onboarding draft (on mount/restore) */
+declare const GetOnboardingDraftOutput: SchemaModel<{
+  id: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: true;
+  };
+  organizationId: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: true;
+  };
+  data: {
+    type: _lssm_lib_schema7.FieldType<unknown, unknown>;
+    isOptional: true;
+  };
+  createdAt: {
+    type: _lssm_lib_schema7.FieldType<Date, string>;
+    isOptional: true;
+  };
+  updatedAt: {
+    type: _lssm_lib_schema7.FieldType<Date, string>;
+    isOptional: true;
+  };
+}>;
+declare const GetOnboardingDraftBaseSpec: ContractSpec<_lssm_lib_schema7.AnySchemaModel, SchemaModel<{
+  id: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: true;
+  };
+  organizationId: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: true;
+  };
+  data: {
+    type: _lssm_lib_schema7.FieldType<unknown, unknown>;
+    isOptional: true;
+  };
+  createdAt: {
+    type: _lssm_lib_schema7.FieldType<Date, string>;
+    isOptional: true;
+  };
+  updatedAt: {
+    type: _lssm_lib_schema7.FieldType<Date, string>;
+    isOptional: true;
+  };
+}>, undefined>;
+/** Delete onboarding draft (cleanup after completion or cancel) */
+declare const DeleteOnboardingDraftOutput: SchemaModel<{
+  ok: {
+    type: _lssm_lib_schema7.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+}>;
+declare const DeleteOnboardingDraftBaseSpec: ContractSpec<_lssm_lib_schema7.AnySchemaModel, SchemaModel<{
+  ok: {
+    type: _lssm_lib_schema7.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+}>, undefined>;
+/** Complete onboarding (final submit, creates entities) */
+declare const CompleteOnboardingBaseInput: SchemaModel<{
+  data: {
+    type: _lssm_lib_schema7.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+}>;
+declare const CompleteOnboardingBaseOutput: SchemaModel<{
+  success: {
+    type: _lssm_lib_schema7.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+  userId: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: true;
+  };
+  organizationId: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: true;
+  };
+}>;
+declare const CompleteOnboardingBaseSpec: ContractSpec<SchemaModel<{
+  data: {
+    type: _lssm_lib_schema7.FieldType<unknown, unknown>;
+    isOptional: false;
+  };
+}>, SchemaModel<{
+  success: {
+    type: _lssm_lib_schema7.FieldType<boolean, boolean>;
+    isOptional: false;
+  };
+  userId: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: true;
+  };
+  organizationId: {
+    type: _lssm_lib_schema7.FieldType<string, string>;
+    isOptional: true;
+  };
+}>, undefined>;
+//#endregion
+export { CompleteOnboardingBaseInput, CompleteOnboardingBaseOutput, CompleteOnboardingBaseSpec, DeleteOnboardingDraftBaseSpec, DeleteOnboardingDraftOutput, GetOnboardingDraftBaseSpec, GetOnboardingDraftOutput, SaveOnboardingDraftBaseSpec, SaveOnboardingDraftInput, SaveOnboardingDraftOutput };

package/dist/openapi.d.ts

@@ -0,0 +1,31 @@
+import { SpecRegistry } from "./registry.js";
+
+//#region src/openapi.d.ts
+
+interface OpenApiServer {
+  url: string;
+  description?: string;
+}
+interface OpenApiExportOptions {
+  title?: string;
+  version?: string;
+  description?: string;
+  servers?: OpenApiServer[];
+}
+type OpenApiSchemaObject = Record<string, unknown>;
+interface OpenApiDocument {
+  openapi: '3.1.0';
+  info: {
+    title: string;
+    version: string;
+    description?: string;
+  };
+  servers?: OpenApiServer[];
+  paths: Record<string, Record<string, unknown>>;
+  components: {
+    schemas: Record<string, OpenApiSchemaObject>;
+  };
+}
+declare function openApiForRegistry(registry: SpecRegistry, options?: OpenApiExportOptions): OpenApiDocument;
+//#endregion
+export { OpenApiDocument, OpenApiExportOptions, OpenApiServer, openApiForRegistry };

package/dist/openbanking/docs/openbanking.docblock.d.ts

@@ -0,0 +1,6 @@
+import { DocBlock } from "@lssm/lib.contracts/docs";
+
+//#region src/openbanking/docs/openbanking.docblock.d.ts
+declare const tech_contracts_openbanking_DocBlocks: DocBlock[];
+//#endregion
+export { tech_contracts_openbanking_DocBlocks };

package/dist/ownership.d.ts

@@ -0,0 +1,75 @@
+//#region src/ownership.d.ts
+declare const StabilityEnum: {
+  readonly Idea: "idea";
+  readonly InCreation: "in_creation";
+  readonly Experimental: "experimental";
+  readonly Beta: "beta";
+  readonly Stable: "stable";
+  readonly Deprecated: "deprecated";
+};
+type Stability = (typeof StabilityEnum)[keyof typeof StabilityEnum];
+declare const OwnersEnum: {
+  readonly ProductColiving: "product.coliving";
+  readonly ProductStrit: "product.strit";
+  readonly ProductArtisanos: "product.artisanos";
+  readonly PlatformSigil: "platform.sigil";
+  readonly PlatformMarketplace: "platform.marketplace";
+  readonly PlatformContent: "platform.content";
+  readonly PlatformFeatureFlags: "platform.featureflags";
+};
+type Owner = (typeof OwnersEnum)[keyof typeof OwnersEnum] | (string & {});
+declare const Owners: {
+  readonly ProductColiving: "product.coliving";
+  readonly ProductStrit: "product.strit";
+  readonly ProductArtisanos: "product.artisanos";
+  readonly PlatformSigil: "platform.sigil";
+  readonly PlatformMarketplace: "platform.marketplace";
+  readonly PlatformContent: "platform.content";
+  readonly PlatformFeatureFlags: "platform.featureflags";
+};
+declare const TagsEnum: {
+  readonly Spots: "spots";
+  readonly Collectivity: "collectivity";
+  readonly Marketplace: "marketplace";
+  readonly Sellers: "sellers";
+  readonly Auth: "auth";
+  readonly Login: "login";
+  readonly Signup: "signup";
+  readonly Guide: "guide";
+  readonly Docs: "docs";
+  readonly I18n: "i18n";
+  readonly AtomicPages: "atomic:pages";
+  readonly Incident: "incident";
+  readonly Hygiene: "hygiene";
+  readonly WeeklyPulse: "weekly_pulse";
+  readonly WebAuth: "webauth";
+};
+type Tag = (typeof TagsEnum)[keyof typeof TagsEnum] | (string & {});
+declare const Tags: {
+  readonly Spots: "spots";
+  readonly Collectivity: "collectivity";
+  readonly Marketplace: "marketplace";
+  readonly Sellers: "sellers";
+  readonly Auth: "auth";
+  readonly Login: "login";
+  readonly Signup: "signup";
+  readonly Guide: "guide";
+  readonly Docs: "docs";
+  readonly I18n: "i18n";
+  readonly AtomicPages: "atomic:pages";
+  readonly Incident: "incident";
+  readonly Hygiene: "hygiene";
+  readonly WeeklyPulse: "weekly_pulse";
+  readonly WebAuth: "webauth";
+};
+interface OwnerShipMeta {
+  version?: number;
+  title: string;
+  description: string;
+  domain: string;
+  owners: Owner[];
+  tags: Tag[];
+  stability: Stability;
+}
+//#endregion
+export { Owner, OwnerShipMeta, Owners, OwnersEnum, Stability, StabilityEnum, Tag, Tags, TagsEnum };

package/dist/policy/docs/policy.docblock.d.ts

@@ -0,0 +1,6 @@
+import { DocBlock } from "@lssm/lib.contracts/docs";
+
+//#region src/policy/docs/policy.docblock.d.ts
+declare const tech_contracts_policy_DocBlocks: DocBlock[];
+//#endregion
+export { tech_contracts_policy_DocBlocks };

package/dist/policy/engine.d.ts

@@ -0,0 +1,39 @@
+import { PolicyRef, PolicyRegistry } from "./spec.js";
+import { PolicyDecision } from "../types.js";
+
+//#region src/policy/engine.d.ts
+interface SubjectRelationship {
+  relation: string;
+  object: string;
+  objectType?: string;
+}
+interface SubjectContext {
+  roles?: string[];
+  attributes?: Record<string, unknown>;
+  relationships?: SubjectRelationship[];
+}
+interface ResourceContext {
+  type: string;
+  id?: string;
+  fields?: string[];
+  attributes?: Record<string, unknown>;
+}
+interface DecisionContext {
+  subject: SubjectContext;
+  resource: ResourceContext;
+  context?: Record<string, unknown>;
+  action: string;
+  policies: PolicyRef[];
+  consents?: string[];
+  flags?: string[];
+}
+declare class PolicyEngine {
+  private readonly registry;
+  constructor(registry: PolicyRegistry);
+  decide(input: DecisionContext): PolicyDecision;
+  private resolvePolicies;
+  private matchRuleSet;
+  private evaluateFields;
+}
+//#endregion
+export { DecisionContext, PolicyEngine, ResourceContext, SubjectContext, SubjectRelationship };

package/dist/policy/opa-adapter.d.ts

@@ -0,0 +1,45 @@
+import { ConsentDefinition, FieldPolicyRule, PIIPolicy, PolicyMeta, PolicyRule, PolicySpec, RateLimitDefinition, RelationshipDefinition } from "./spec.js";
+import { PolicyDecision } from "../types.js";
+import { DecisionContext } from "./engine.js";
+
+//#region src/policy/opa-adapter.d.ts
+interface OPAClient {
+  evaluate<T>(decisionPath: string, input: unknown): Promise<T>;
+}
+interface OPAEvaluationResult {
+  effect?: 'allow' | 'deny';
+  reason?: string;
+  fieldDecisions?: PolicyDecision['fieldDecisions'];
+  requiredConsents?: string[];
+}
+interface OPAAdapterOptions<Result = OPAEvaluationResult | null> {
+  /**
+   * Path fed to the OPA client (e.g., "sigil/authz/allow").
+   */
+  decisionPath: string;
+  /**
+   * Optional mapper when the OPA client returns a non-standard payload.
+   */
+  mapResult?: (value: unknown) => Result;
+}
+declare class OPAPolicyAdapter<Result = OPAEvaluationResult | null> {
+  private readonly client;
+  private readonly options;
+  constructor(client: OPAClient, options: OPAAdapterOptions<Result>);
+  evaluate(context: DecisionContext, policies: PolicySpec[], engineDecision: PolicyDecision): Promise<PolicyDecision>;
+}
+declare function buildOPAInput(context: DecisionContext, policies: PolicySpec[], engineDecision: PolicyDecision): {
+  context: DecisionContext;
+  decision: PolicyDecision;
+  policies: {
+    meta: PolicyMeta;
+    rules: PolicyRule[];
+    fieldPolicies: FieldPolicyRule[] | undefined;
+    pii: PIIPolicy | undefined;
+    relationships: RelationshipDefinition[] | undefined;
+    consents: ConsentDefinition[] | undefined;
+    rateLimits: RateLimitDefinition[] | undefined;
+  }[];
+};
+//#endregion
+export { OPAAdapterOptions, OPAClient, OPAEvaluationResult, OPAPolicyAdapter, buildOPAInput };

package/dist/policy/spec.d.ts

@@ -0,0 +1,114 @@
+import { OwnerShipMeta } from "../ownership.js";
+
+//#region src/policy/spec.d.ts
+type PolicyEffect = 'allow' | 'deny';
+interface RelationshipDefinition {
+  subjectType: string;
+  relation: string;
+  objectType: string;
+  description?: string;
+  transitive?: boolean;
+}
+interface RelationshipMatcher {
+  relation: string;
+  objectType?: string;
+  objectId?: string;
+}
+interface ConsentDefinition {
+  id: string;
+  scope: string;
+  purpose: string;
+  description?: string;
+  lawfulBasis?: 'consent' | 'contract' | 'legal_obligation' | 'legitimate_interest';
+  expiresInDays?: number;
+  required?: boolean;
+}
+interface RateLimitDefinition {
+  id: string;
+  rpm: number;
+  key?: string;
+  windowSeconds?: number;
+  burst?: number;
+}
+interface PolicyOPAConfig {
+  /** Fully-qualified package, e.g. "sigil.authz" */
+  package: string;
+  /** Optional rule within package (defaults to "allow") */
+  decision?: string;
+}
+interface PolicyMeta extends OwnerShipMeta {
+  /** Fully-qualified policy name (e.g., "sigil.core.default"). */
+  name: string;
+  /** Version of the policy; bump on breaking changes. */
+  version: number;
+  /** Optional scope hint used for discovery. */
+  scope?: 'global' | 'feature' | 'operation';
+}
+interface AttributeMatcher {
+  equals?: unknown;
+  oneOf?: unknown[];
+  exists?: boolean;
+}
+interface SubjectMatcher {
+  roles?: string[];
+  attributes?: Record<string, AttributeMatcher>;
+}
+interface ResourceMatcher {
+  type: string;
+  fields?: string[];
+  attributes?: Record<string, AttributeMatcher>;
+}
+interface PolicyCondition {
+  /** Simple expression evaluated against { subject, resource, context }. */
+  expression: string;
+}
+interface PolicyRule {
+  effect: PolicyEffect;
+  actions: string[];
+  subject?: SubjectMatcher;
+  resource?: ResourceMatcher;
+  relationships?: RelationshipMatcher[];
+  requiresConsent?: string[];
+  flags?: string[];
+  rateLimit?: string | RateLimitDefinition;
+  escalate?: 'human_review' | null;
+  conditions?: PolicyCondition[];
+  reason?: string;
+}
+interface FieldPolicyRule {
+  effect: PolicyEffect;
+  field: string;
+  actions: ('read' | 'write')[];
+  subject?: SubjectMatcher;
+  resource?: ResourceMatcher;
+  conditions?: PolicyCondition[];
+  reason?: string;
+}
+interface PIIPolicy {
+  fields: string[];
+  consentRequired?: boolean;
+  retentionDays?: number;
+}
+interface PolicySpec {
+  meta: PolicyMeta;
+  rules: PolicyRule[];
+  fieldPolicies?: FieldPolicyRule[];
+  pii?: PIIPolicy;
+  relationships?: RelationshipDefinition[];
+  consents?: ConsentDefinition[];
+  rateLimits?: RateLimitDefinition[];
+  opa?: PolicyOPAConfig;
+}
+interface PolicyRef {
+  name: string;
+  version: number;
+}
+declare class PolicyRegistry {
+  private readonly items;
+  register(spec: PolicySpec): this;
+  list(): PolicySpec[];
+  get(name: string, version?: number): PolicySpec | undefined;
+}
+declare function makePolicyKey(ref: PolicyRef): string;
+//#endregion
+export { AttributeMatcher, ConsentDefinition, FieldPolicyRule, PIIPolicy, PolicyCondition, PolicyEffect, PolicyMeta, PolicyOPAConfig, PolicyRef, PolicyRegistry, PolicyRule, PolicySpec, RateLimitDefinition, RelationshipDefinition, RelationshipMatcher, ResourceMatcher, SubjectMatcher, makePolicyKey };

package/dist/presentations/docs/presentations-conventions.docblock.d.ts

@@ -0,0 +1,6 @@
+import { DocBlock } from "@lssm/lib.contracts/docs";
+
+//#region src/presentations/docs/presentations-conventions.docblock.d.ts
+declare const tech_contracts_presentations_conventions_DocBlocks: DocBlock[];
+//#endregion
+export { tech_contracts_presentations_conventions_DocBlocks };

package/dist/presentations.backcompat.d.ts

@@ -0,0 +1,7 @@
+import { PresentationDescriptorV2 } from "./presentations.v2.js";
+import { PresentationSpec } from "./presentations.js";
+
+//#region src/presentations.backcompat.d.ts
+declare function toV2FromV1(v1: PresentationSpec): PresentationDescriptorV2;
+//#endregion
+export { toV2FromV1 };

package/dist/presentations.d.ts

@@ -0,0 +1,98 @@
+import { Stability } from "./ownership.js";
+import * as _lssm_lib_schema35 from "@lssm/lib.schema";
+import { AnySchemaModel } from "@lssm/lib.schema";
+import z from "zod";
+
+//#region src/presentations.d.ts
+/** V1 presentation kinds (back-compat). Prefer V2 descriptors for new work. */
+type PresentationKind = 'web_component' | 'markdown' | 'data';
+/** Minimal metadata for presentations (V1). */
+interface PresentationMeta {
+  name: string;
+  version: number;
+  stability?: Stability;
+  owners?: string[];
+  tags?: string[];
+  description?: string;
+}
+/** Policy for presentations (flags, pii). */
+interface PresentationPolicy {
+  flags?: string[];
+  pii?: string[];
+}
+/** Web component presentation (V1). */
+interface WebComponentPresentation {
+  kind: 'web_component';
+  framework: 'react';
+  /** Symbolic key resolved by host via component map */
+  componentKey: string;
+  /** Props schema (validated at runtime) */
+  props: AnySchemaModel;
+  analytics?: string[];
+}
+/** Markdown presentation (V1). */
+interface MarkdownPresentation {
+  kind: 'markdown';
+  /** Inline markdown/MDX content */
+  content?: string;
+  /** Or a resolvable resource URI handled by ResourceRegistry */
+  resourceUri?: string;
+}
+/** Data presentation (V1): structured export description. */
+interface DataPresentation {
+  kind: 'data';
+  mimeType: string;
+  /** Structured data schema */
+  model: AnySchemaModel;
+}
+type PresentationContent = WebComponentPresentation | MarkdownPresentation | DataPresentation;
+interface PresentationSpec {
+  meta: PresentationMeta;
+  policy?: PresentationPolicy;
+  content: PresentationContent;
+}
+/** In-memory registry for V1 PresentationSpec. */
+declare class PresentationRegistry {
+  private items;
+  constructor(items?: PresentationSpec[]);
+  register(p: PresentationSpec): this;
+  list(): PresentationSpec[];
+  get(name: string, version?: number): PresentationSpec | undefined;
+}
+declare function jsonSchemaForPresentation(p: PresentationSpec): {
+  framework: "react";
+  componentKey: string;
+  props: z.core.ZodStandardJSONSchemaPayload<_lssm_lib_schema35.TopLevelZodFromModel<_lssm_lib_schema35.SchemaModelFieldsAnyConfig<AnySchemaModel | _lssm_lib_schema35.AnyFieldType | _lssm_lib_schema35.AnyEnumType>>>;
+  meta: {
+    readonly name: string;
+    readonly version: number;
+    readonly stability: Stability;
+    readonly tags: string[];
+    readonly description: string;
+  };
+  kind: PresentationKind;
+} | {
+  content: string | undefined;
+  resourceUri: string | undefined;
+  meta: {
+    readonly name: string;
+    readonly version: number;
+    readonly stability: Stability;
+    readonly tags: string[];
+    readonly description: string;
+  };
+  kind: PresentationKind;
+} | {
+  mimeType: string;
+  model: z.core.ZodStandardJSONSchemaPayload<_lssm_lib_schema35.TopLevelZodFromModel<_lssm_lib_schema35.SchemaModelFieldsAnyConfig<AnySchemaModel | _lssm_lib_schema35.AnyFieldType | _lssm_lib_schema35.AnyEnumType>>>;
+  meta: {
+    readonly name: string;
+    readonly version: number;
+    readonly stability: Stability;
+    readonly tags: string[];
+    readonly description: string;
+  };
+  kind: PresentationKind;
+};
+//#endregion
+export { DataPresentation, MarkdownPresentation, PresentationContent, PresentationKind, PresentationMeta, PresentationPolicy, PresentationRegistry, PresentationSpec, WebComponentPresentation, jsonSchemaForPresentation };