@contractspec/lib.contracts 0.0.0-canary-20260113162409

package/dist/policy/engine.js

@@ -0,0 +1,225 @@
+import "./registry.js";
+
+//#region src/policy/engine.ts
+var PolicyEngine = class {
+	constructor(registry) {
+		this.registry = registry;
+	}
+	decide(input) {
+		const policies = this.resolvePolicies(input.policies);
+		let allowReason;
+		let appliedRateLimit;
+		let escalate;
+		for (const policy of policies) {
+			const match = this.matchRuleSet(policy, input);
+			if (!match) continue;
+			if (match.rule.effect === "deny") return {
+				effect: "deny",
+				reason: match.rule.reason ?? policy.meta.key,
+				requiredConsents: match.missingConsents.length ? match.missingConsents : void 0,
+				evaluatedBy: "engine"
+			};
+			if (match.rule.effect === "allow") {
+				if (match.missingConsents.length) return {
+					effect: "deny",
+					reason: "consent_required",
+					requiredConsents: match.missingConsents,
+					evaluatedBy: "engine"
+				};
+				if (!allowReason) allowReason = match.rule.reason ?? policy.meta.key;
+				if (!appliedRateLimit && match.rateLimit) appliedRateLimit = match.rateLimit;
+				if (!escalate && match.rule.escalate) escalate = match.rule.escalate;
+			}
+		}
+		const fieldDecisions = this.evaluateFields(policies, input);
+		const pii = policies.find((p) => p.pii)?.pii;
+		return {
+			effect: allowReason ? "allow" : "deny",
+			reason: allowReason,
+			rateLimit: appliedRateLimit,
+			escalate: typeof escalate === "undefined" ? void 0 : escalate,
+			fieldDecisions: fieldDecisions.length ? fieldDecisions : void 0,
+			pii,
+			evaluatedBy: "engine"
+		};
+	}
+	resolvePolicies(refs) {
+		const specs = [];
+		for (const ref of refs) {
+			const spec = this.registry.get(ref.key, ref.version);
+			if (!spec) throw new Error(`PolicyEngine: policy not found ${ref.key}.v${ref.version}`);
+			specs.push(spec);
+		}
+		return specs;
+	}
+	matchRuleSet(policy, input) {
+		let allowMatch;
+		for (const rule of policy.rules) {
+			if (!rule.actions.includes(input.action)) continue;
+			if (!matchesSubject(rule, input.subject)) continue;
+			if (!matchesResource(rule, input.resource)) continue;
+			if (!matchesFlags(rule, input)) continue;
+			if (!matchesRelationships(rule.relationships, input)) continue;
+			if (!matchesConditions(rule, input)) continue;
+			const evaluation = {
+				rule,
+				missingConsents: collectMissingConsents(rule, policy, input),
+				rateLimit: resolveRateLimit(rule, policy, input)
+			};
+			if (rule.effect === "deny") return evaluation;
+			if (rule.effect === "allow" && !allowMatch) allowMatch = evaluation;
+		}
+		return allowMatch;
+	}
+	evaluateFields(policies, input) {
+		const out = /* @__PURE__ */ new Map();
+		for (const policy of policies) {
+			if (!policy.fieldPolicies) continue;
+			for (const rule of policy.fieldPolicies) {
+				if (!rule.actions.includes(mapActionToFieldAction(input.action))) continue;
+				if (!matchesSubject(rule, input.subject)) continue;
+				if (!matchesResource(rule, input.resource)) continue;
+				if (!matchesConditions(rule, input)) continue;
+				const existing = out.get(rule.field);
+				if (rule.effect === "deny") out.set(rule.field, {
+					field: rule.field,
+					effect: "deny",
+					reason: rule.reason ?? policy.meta.key
+				});
+				else if (!existing) out.set(rule.field, {
+					field: rule.field,
+					effect: "allow",
+					reason: rule.reason ?? policy.meta.key
+				});
+			}
+		}
+		return [...out.values()];
+	}
+};
+function mapActionToFieldAction(action) {
+	if (action.startsWith("write")) return "write";
+	return "read";
+}
+function matchesSubject(rule, subject) {
+	const matcher = rule.subject;
+	if (!matcher) return true;
+	if (matcher.roles?.length) {
+		const roles = subject.roles ?? [];
+		if (!matcher.roles.some((role) => roles.includes(role))) return false;
+	}
+	if (matcher.attributes) {
+		const attributes = subject.attributes ?? {};
+		if (!matchAttributes(matcher.attributes, attributes)) return false;
+	}
+	return true;
+}
+function matchesResource(rule, resource) {
+	const matcher = rule.resource;
+	if (!matcher) return true;
+	if (matcher.type && matcher.type !== resource.type) return false;
+	if (matcher.fields?.length) {
+		const targetFields = resource.fields ?? [];
+		if (!matcher.fields.some((field) => targetFields.includes(field))) return false;
+	}
+	if (matcher.attributes) {
+		const attributes = resource.attributes ?? {};
+		if (!matchAttributes(matcher.attributes, attributes)) return false;
+	}
+	return true;
+}
+function matchesFlags(rule, input) {
+	if (!rule.flags?.length) return true;
+	const available = /* @__PURE__ */ new Set();
+	if (input.flags) for (const flag of input.flags) available.add(flag);
+	const attributeFlags = input.subject.attributes?.featureFlags;
+	if (Array.isArray(attributeFlags)) for (const flag of attributeFlags) available.add(flag);
+	return rule.flags.every((flag) => available.has(flag));
+}
+function matchesRelationships(matchers, input) {
+	if (!matchers || matchers.length === 0) return true;
+	const relationships = input.subject.relationships ?? [];
+	const resourceId = getResourceId(input.resource);
+	const resourceType = input.resource.type;
+	return matchers.every((matcher) => relationships.some((relation) => {
+		if (relation.relation !== matcher.relation) return false;
+		if (!(!matcher.objectType || relation.objectType === matcher.objectType || matcher.objectType === resourceType)) return false;
+		if (!matcher.objectId) return true;
+		if (matcher.objectId === "$resource") {
+			if (resourceId) return relation.object === resourceId;
+			return relation.object === resourceType || relation.objectType === resourceType;
+		}
+		return relation.object === matcher.objectId;
+	}));
+}
+function matchesConditions(rule, input) {
+	if (!rule.conditions || rule.conditions.length === 0) return true;
+	return rule.conditions.every((condition) => evaluateCondition(condition.expression, input));
+}
+function matchAttributes(matcher, actual) {
+	for (const [key, attrMatcher] of Object.entries(matcher)) {
+		const value = actual[key];
+		if (attrMatcher.exists && typeof value === "undefined") return false;
+		if (typeof attrMatcher.equals !== "undefined") {
+			if (value !== attrMatcher.equals) return false;
+		}
+		if (attrMatcher.oneOf && !attrMatcher.oneOf.includes(value)) return false;
+	}
+	return true;
+}
+function collectMissingConsents(rule, policy, input) {
+	if (!rule.requiresConsent?.length) return [];
+	const granted = new Set(input.consents ?? []);
+	const missingIds = rule.requiresConsent.filter((id) => !granted.has(id));
+	if (missingIds.length === 0) return [];
+	return resolveConsentDefinitions(policy, missingIds);
+}
+function resolveConsentDefinitions(policy, ids) {
+	const catalog = policy.consents ?? [];
+	return ids.map((id) => {
+		return catalog.find((consent) => consent.id === id) ?? {
+			id,
+			scope: "unspecified",
+			purpose: "unspecified",
+			description: `Consent "${id}" required by ${policy.meta.key}`,
+			required: true
+		};
+	});
+}
+function resolveRateLimit(rule, policy, input) {
+	if (!rule.rateLimit) return void 0;
+	const definition = typeof rule.rateLimit === "string" ? (policy.rateLimits ?? []).find((item) => item.id === rule.rateLimit) : rule.rateLimit;
+	if (!definition) throw new Error(`PolicyEngine: rate limit "${String(rule.rateLimit)}" not declared in ${policy.meta.key}`);
+	return {
+		rpm: definition.rpm,
+		key: definition.key ?? input.resource.type,
+		windowSeconds: definition.windowSeconds,
+		burst: definition.burst
+	};
+}
+function evaluateCondition(expression, input) {
+	const trimmed = expression.trim();
+	if (!trimmed) return true;
+	const context = {
+		subject: input.subject,
+		resource: input.resource,
+		context: input.context ?? {}
+	};
+	try {
+		const result = new Function("subject", "resource", "context", `return (${transformExpression(trimmed)});`)(context.subject, context.resource, context.context);
+		return Boolean(result);
+	} catch (_error) {
+		return false;
+	}
+}
+function transformExpression(expression) {
+	return expression.replace(/&&/g, "&&").replace(/\|\|/g, "||");
+}
+function getResourceId(resource) {
+	if (resource.id) return resource.id;
+	const candidate = resource.attributes?.id;
+	if (typeof candidate === "string") return candidate;
+	if (typeof candidate === "number") return String(candidate);
+}
+
+//#endregion
+export { PolicyEngine };

package/dist/policy/index.d.ts

@@ -0,0 +1,5 @@
+import { AttributeMatcher, ConsentDefinition, FieldPolicyRule, PIIPolicy, PolicyCondition, PolicyEffect, PolicyMeta, PolicyOPAConfig, PolicyRef, PolicyRule, PolicySpec, RateLimitDefinition, RelationshipDefinition, RelationshipMatcher, ResourceMatcher, SubjectMatcher } from "./spec.js";
+import { PolicyRegistry } from "./registry.js";
+import { DecisionContext, PolicyEngine, ResourceContext, SubjectContext, SubjectRelationship } from "./engine.js";
+import { OPAAdapterOptions, OPAClient, OPAEvaluationResult, OPAPolicyAdapter, buildOPAInput } from "./opa-adapter.js";
+export { AttributeMatcher, ConsentDefinition, DecisionContext, FieldPolicyRule, OPAAdapterOptions, OPAClient, OPAEvaluationResult, OPAPolicyAdapter, PIIPolicy, PolicyCondition, PolicyEffect, PolicyEngine, PolicyMeta, PolicyOPAConfig, PolicyRef, PolicyRegistry, PolicyRule, PolicySpec, RateLimitDefinition, RelationshipDefinition, RelationshipMatcher, ResourceContext, ResourceMatcher, SubjectContext, SubjectMatcher, SubjectRelationship, buildOPAInput };

package/dist/policy/index.js

@@ -0,0 +1,5 @@
+import { PolicyRegistry } from "./registry.js";
+import { PolicyEngine } from "./engine.js";
+import { OPAPolicyAdapter, buildOPAInput } from "./opa-adapter.js";
+
+export { OPAPolicyAdapter, PolicyEngine, PolicyRegistry, buildOPAInput };

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/opa-adapter.js

@@ -0,0 +1,71 @@
+//#region src/policy/opa-adapter.ts
+var OPAPolicyAdapter = class {
+	constructor(client, options) {
+		this.client = client;
+		this.options = options;
+	}
+	async evaluate(context, policies, engineDecision) {
+		const input = buildOPAInput(context, policies, engineDecision);
+		const raw = await this.client.evaluate(this.options.decisionPath, input);
+		const resolved = this.options.mapResult ? this.options.mapResult(raw) : raw;
+		if (!resolved) return {
+			...engineDecision,
+			evaluatedBy: engineDecision.evaluatedBy ?? "engine"
+		};
+		const opaResult = resolved;
+		const mergedRequiredConsents = mergeRequiredConsents(policies, engineDecision.requiredConsents ?? [], opaResult.requiredConsents ?? []);
+		return {
+			...engineDecision,
+			effect: opaResult.effect ?? engineDecision.effect,
+			reason: opaResult.reason ?? engineDecision.reason,
+			fieldDecisions: opaResult.fieldDecisions ?? engineDecision.fieldDecisions,
+			requiredConsents: mergedRequiredConsents.length ? mergedRequiredConsents : void 0,
+			evaluatedBy: "opa"
+		};
+	}
+};
+function buildOPAInput(context, policies, engineDecision) {
+	return {
+		context,
+		decision: engineDecision,
+		policies: policies.map((policy) => ({
+			meta: policy.meta,
+			rules: policy.rules,
+			fieldPolicies: policy.fieldPolicies,
+			pii: policy.pii,
+			relationships: policy.relationships,
+			consents: policy.consents,
+			rateLimits: policy.rateLimits
+		}))
+	};
+}
+function mergeRequiredConsents(policies, existing, incomingIds) {
+	if (incomingIds.length === 0) return existing;
+	const existingIds = new Set(existing.map((consent) => consent.id));
+	const merged = [...existing];
+	for (const id of incomingIds) {
+		if (existingIds.has(id)) continue;
+		const resolved = resolveConsentAcrossPolicies(policies, id);
+		if (resolved) {
+			merged.push(resolved);
+			existingIds.add(resolved.id);
+		}
+	}
+	return merged;
+}
+function resolveConsentAcrossPolicies(policies, id) {
+	for (const policy of policies) {
+		const match = policy.consents?.find((consent) => consent.id === id);
+		if (match) return match;
+	}
+	return {
+		id,
+		scope: "unspecified",
+		purpose: "unspecified",
+		description: `Consent "${id}" returned by OPA`,
+		required: true
+	};
+}
+
+//#endregion
+export { OPAPolicyAdapter, buildOPAInput };

package/dist/policy/registry.d.ts

@@ -0,0 +1,9 @@
+import { PolicySpec } from "./spec.js";
+import { SpecContractRegistry } from "../registry.js";
+
+//#region src/policy/registry.d.ts
+declare class PolicyRegistry extends SpecContractRegistry<'policy', PolicySpec> {
+  constructor(items?: PolicySpec[]);
+}
+//#endregion
+export { PolicyRegistry };

package/dist/policy/registry.js

@@ -0,0 +1,11 @@
+import { SpecContractRegistry } from "../registry.js";
+
+//#region src/policy/registry.ts
+var PolicyRegistry = class extends SpecContractRegistry {
+	constructor(items) {
+		super("policy", items);
+	}
+};
+
+//#endregion
+export { PolicyRegistry };

package/dist/policy/spec.d.ts

@@ -0,0 +1,103 @@
+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 {
+  /** 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 {
+  key: string;
+  version: string;
+}
+//#endregion
+export { AttributeMatcher, ConsentDefinition, FieldPolicyRule, PIIPolicy, PolicyCondition, PolicyEffect, PolicyMeta, PolicyOPAConfig, PolicyRef, PolicyRule, PolicySpec, RateLimitDefinition, RelationshipDefinition, RelationshipMatcher, ResourceMatcher, SubjectMatcher };

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

@@ -0,0 +1,6 @@
+import { DocBlock } from "@contractspec/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/docs/presentations-conventions.docblock.js

@@ -0,0 +1,21 @@
+import { registerDocBlocks } from "../../docs/registry.js";
+
+//#region src/presentations/docs/presentations-conventions.docblock.ts
+const tech_contracts_presentations_conventions_DocBlocks = [{
+	id: "docs.tech.contracts.presentations-conventions",
+	title: "Presentations Conventions (A11y & i18n)",
+	summary: "- Always provide `meta.description` (≥ 3 chars) — used by a11y/docs/agents.",
+	kind: "reference",
+	visibility: "public",
+	route: "/docs/tech/contracts/presentations-conventions",
+	tags: [
+		"tech",
+		"contracts",
+		"presentations-conventions"
+	],
+	body: "## Presentations Conventions (A11y & i18n)\n\n- Always provide `meta.description` (≥ 3 chars) — used by a11y/docs/agents.\n- Prefer source = BlockNote for rich guides; use component key for interactive flows.\n- i18n strings belong in host apps; descriptors carry keys/defaults only.\n- Target selection: include only what you intend to support to avoid drift.\n- PII: declare JSON-like paths under `policy.pii`; engine redacts in outputs.\n"
+}];
+registerDocBlocks(tech_contracts_presentations_conventions_DocBlocks);
+
+//#endregion
+export { tech_contracts_presentations_conventions_DocBlocks };

package/dist/presentations/index.d.ts

@@ -0,0 +1,4 @@
+import { PresentationSource, PresentationSourceBlocknotejs, PresentationSourceComponentReact, PresentationSpec, PresentationSpecMeta, PresentationTarget, definePresentation } from "./presentations.js";
+import { ComponentMap, PresentationRenderer, PresentationValidator, ReactRenderDescriptor, RenderContext, TransformEngine, createDefaultTransformEngine, registerBasicValidation, registerDefaultReactRenderer, registerReactToMarkdownRenderer } from "./transform-engine.js";
+import { PresentationRegistry } from "./registry.js";
+export { ComponentMap, PresentationRegistry, PresentationRenderer, PresentationSource, PresentationSourceBlocknotejs, PresentationSourceComponentReact, PresentationSpec, PresentationSpecMeta, PresentationTarget, PresentationValidator, ReactRenderDescriptor, RenderContext, TransformEngine, createDefaultTransformEngine, definePresentation, registerBasicValidation, registerDefaultReactRenderer, registerReactToMarkdownRenderer };

package/dist/presentations/index.js

@@ -0,0 +1,5 @@
+import { TransformEngine, createDefaultTransformEngine, registerBasicValidation, registerDefaultReactRenderer, registerReactToMarkdownRenderer } from "./transform-engine.js";
+import { definePresentation } from "./presentations.js";
+import { PresentationRegistry } from "./registry.js";
+
+export { PresentationRegistry, TransformEngine, createDefaultTransformEngine, definePresentation, registerBasicValidation, registerDefaultReactRenderer, registerReactToMarkdownRenderer };

package/dist/presentations/presentations.d.ts

@@ -0,0 +1,50 @@
+import { OwnerShipMeta } from "../ownership.js";
+import { AnySchemaModel } from "@contractspec/lib.schema";
+import { BlockConfig } from "@blocknote/core";
+
+//#region src/presentations/presentations.d.ts
+/** Supported render targets for the transform engine and descriptors. */
+type PresentationTarget = 'react' | 'markdown' | 'application/json' | 'application/xml';
+interface PresentationSpecMeta extends OwnerShipMeta {
+  /** Business goal: why this exists */
+  goal: string;
+  /** Background, constraints, scope edges (feeds docs & LLM context) */
+  context: string;
+}
+/** React component presentation source. */
+interface PresentationSourceComponentReact {
+  /** Source marker for React component presentations. */
+  type: 'component';
+  /** Framework for the component source (currently only 'react'). */
+  framework: 'react';
+  /** Component key resolved by host `componentMap`. */
+  componentKey: string;
+  /** Optional props schema to validate against. */
+  props?: AnySchemaModel;
+}
+/** BlockNoteJS document presentation source. */
+interface PresentationSourceBlocknotejs {
+  /** Source marker for BlockNoteJS document presentations. */
+  type: 'blocknotejs';
+  /** BlockNoteJS JSON document. */
+  docJson: unknown;
+  /** Optional BlockNote config to guide rendering. */
+  blockConfig?: BlockConfig;
+}
+type PresentationSource = PresentationSourceComponentReact | PresentationSourceBlocknotejs;
+/**
+ * Normalized presentation spec decoupled from framework/adapters.
+ * Renderers and validators are provided via TransformEngine.
+ */
+interface PresentationSpec {
+  meta: PresentationSpecMeta;
+  policy?: {
+    flags?: string[];
+    pii?: string[];
+  };
+  source: PresentationSource;
+  targets: PresentationTarget[];
+}
+declare const definePresentation: (spec: PresentationSpec) => PresentationSpec;
+//#endregion
+export { PresentationSource, PresentationSourceBlocknotejs, PresentationSourceComponentReact, PresentationSpec, PresentationSpecMeta, PresentationTarget, definePresentation };

package/dist/presentations/presentations.js

@@ -0,0 +1,7 @@
+//#region src/presentations/presentations.ts
+const definePresentation = (spec) => {
+	return spec;
+};
+
+//#endregion
+export { definePresentation };

package/dist/presentations/registry.d.ts

@@ -0,0 +1,10 @@
+import { PresentationSpec } from "./presentations.js";
+import { SpecContractRegistry } from "../registry.js";
+
+//#region src/presentations/registry.d.ts
+/** In-memory registry for PresentationSpec. */
+declare class PresentationRegistry extends SpecContractRegistry<'presentation', PresentationSpec> {
+  constructor(items?: PresentationSpec[]);
+}
+//#endregion
+export { PresentationRegistry };

package/dist/presentations/registry.js

@@ -0,0 +1,12 @@
+import { SpecContractRegistry } from "../registry.js";
+
+//#region src/presentations/registry.ts
+/** In-memory registry for PresentationSpec. */
+var PresentationRegistry = class extends SpecContractRegistry {
+	constructor(items) {
+		super("presentation", items);
+	}
+};
+
+//#endregion
+export { PresentationRegistry };