@openplanr/protocol 0.2.0

package/src/design-contracts.d.mts

@@ -0,0 +1,62 @@
+export type DesignView = 'canvas' | 'prototype' | 'walkthrough';
+
+export interface DesignSource {
+  /** Local HTML path relative to the authored document directory. */
+  html: string;
+  styles?: string[];
+  scripts?: string[];
+}
+
+export interface DesignFrame {
+  id: string;
+  label: string;
+  width: number;
+  height: number;
+}
+
+export interface DesignScreen {
+  id: string;
+  title: string;
+  description?: string;
+  source: DesignSource;
+  /** Stable feedback anchors, unique within this screen. */
+  anchors?: string[];
+}
+
+export interface DesignVariant {
+  id: string;
+  label: string;
+  description?: string;
+  status: 'ready' | 'failed';
+  /** Required for failed variants. */
+  issue?: string;
+  /** Sparse screen overrides inherit unchanged sources from screens. */
+  sources?: Record<string, DesignSource>;
+}
+
+export interface DesignDocument {
+  kind: 'openplanr-design-document';
+  schemaVersion: '1.0.0';
+  id: string;
+  title: string;
+  brief: {
+    text: string;
+    source: 'spec' | 'png' | 'describe';
+    provenance: 'spec' | 'inferred';
+    references?: string[];
+  };
+  designSystem?: { path?: string; tokens?: string; spacing?: number[] };
+  assets?: string[];
+  frames: DesignFrame[];
+  screens: DesignScreen[];
+  screenOrder: string[];
+  flows?: { id: string; title: string; screens: string[] }[];
+  variants: DesignVariant[];
+  selectedVariant: string;
+  defaultView: DesignView;
+}
+
+export declare const DESIGN_DOCUMENT_VERSION: '1.0.0';
+export declare const DESIGN_DOCUMENT_SCHEMA: Readonly<Record<string, unknown>>;
+export declare function validateDesignDocument(value: unknown): { ok: boolean; errors: string[] };
+export declare function assertDesignDocument(value: unknown): DesignDocument;

package/src/design-contracts.mjs

@@ -0,0 +1,186 @@
+import { validateJson } from './json-schema.mjs';
+
+/** The authored document version is independent of the Protocol release. */
+export const DESIGN_DOCUMENT_VERSION = '1.0.0';
+
+const freeze = (value) => {
+  if (value && typeof value === 'object') {
+    for (const nested of Object.values(value)) freeze(nested);
+    Object.freeze(value);
+  }
+  return value;
+};
+
+/**
+ * Portable source of truth for the packaged Protocol 1.9 schema. Rendering,
+ * file existence, symlink containment and revisions belong to the design domain.
+ */
+export const DESIGN_DOCUMENT_SCHEMA = freeze({
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  $id: 'https://openplanr.dev/schemas/v1.9.0/design-document.schema.json',
+  'x-openplanr-contract': { id: 'design-document', version: '1.9.0' },
+  title: 'OpenPlanr authored design document',
+  type: 'object',
+  additionalProperties: false,
+  required: [
+    'kind', 'schemaVersion', 'id', 'title', 'brief', 'frames', 'screens',
+    'screenOrder', 'variants', 'selectedVariant', 'defaultView',
+  ],
+  properties: {
+    kind: { const: 'openplanr-design-document' },
+    schemaVersion: { const: DESIGN_DOCUMENT_VERSION },
+    id: { $ref: '#/$defs/id' },
+    title: { $ref: '#/$defs/text' },
+    brief: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['text', 'source', 'provenance'],
+      properties: {
+        text: { $ref: '#/$defs/text' },
+        source: { enum: ['spec', 'png', 'describe'] },
+        provenance: { enum: ['spec', 'inferred'] },
+        references: { type: 'array', items: { $ref: '#/$defs/text' }, uniqueItems: true },
+      },
+    },
+    designSystem: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        path: { $ref: '#/$defs/localPath' },
+        tokens: { $ref: '#/$defs/localPath' },
+        spacing: {
+          type: 'array', minItems: 1, uniqueItems: true,
+          items: { type: 'number', minimum: 0, maximum: 16384 },
+        },
+      },
+    },
+    assets: { $ref: '#/$defs/paths' },
+    frames: {
+      type: 'array', minItems: 1,
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['id', 'label', 'width', 'height'],
+        properties: {
+          id: { $ref: '#/$defs/id' },
+          label: { $ref: '#/$defs/text' },
+          width: { type: 'integer', minimum: 1, maximum: 16384 },
+          height: { type: 'integer', minimum: 1, maximum: 16384 },
+        },
+      },
+    },
+    screens: {
+      type: 'array', minItems: 1,
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['id', 'title', 'source'],
+        properties: {
+          id: { $ref: '#/$defs/id' },
+          title: { $ref: '#/$defs/text' },
+          description: { $ref: '#/$defs/text' },
+          source: { $ref: '#/$defs/source' },
+          anchors: { $ref: '#/$defs/ids' },
+        },
+      },
+    },
+    screenOrder: { type: 'array', minItems: 1, items: { $ref: '#/$defs/id' }, uniqueItems: true },
+    flows: {
+      type: 'array',
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['id', 'title', 'screens'],
+        properties: {
+          id: { $ref: '#/$defs/id' },
+          title: { $ref: '#/$defs/text' },
+          screens: { type: 'array', minItems: 1, items: { $ref: '#/$defs/id' } },
+        },
+      },
+    },
+    variants: {
+      type: 'array', minItems: 1,
+      items: {
+        type: 'object', additionalProperties: false,
+        required: ['id', 'label', 'status'],
+        properties: {
+          id: { $ref: '#/$defs/id' },
+          label: { $ref: '#/$defs/text' },
+          description: { $ref: '#/$defs/text' },
+          status: { enum: ['ready', 'failed'] },
+          issue: { $ref: '#/$defs/text' },
+          sources: { type: 'object', additionalProperties: { $ref: '#/$defs/source' } },
+        },
+        if: { properties: { status: { const: 'failed' } } },
+        then: { required: ['issue'] },
+      },
+    },
+    selectedVariant: { $ref: '#/$defs/id' },
+    defaultView: { enum: ['canvas', 'prototype', 'walkthrough'] },
+  },
+  $defs: {
+    id: { type: 'string', minLength: 1, maxLength: 128, pattern: '^[A-Za-z][A-Za-z0-9_-]*$' },
+    text: { type: 'string', minLength: 1, pattern: '\\S' },
+    ids: { type: 'array', items: { $ref: '#/$defs/id' }, uniqueItems: true },
+    localPath: {
+      type: 'string', minLength: 1,
+      description: 'Path relative to the authored document directory. No URL, traversal, encoded path, query or fragment.',
+      pattern: '^(?!/)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*//)(?!.*[/ ]$)[^\\\\:\\u0000-\\u001F%?#]+$',
+    },
+    paths: { type: 'array', items: { $ref: '#/$defs/localPath' }, uniqueItems: true },
+    source: {
+      type: 'object', additionalProperties: false, required: ['html'],
+      properties: {
+        html: { $ref: '#/$defs/localPath' },
+        styles: { $ref: '#/$defs/paths' },
+        scripts: { $ref: '#/$defs/paths' },
+      },
+    },
+  },
+});
+
+/** Validate structure plus stable identity and cross-reference constraints. */
+export function validateDesignDocument(value) {
+  const errors = validateJson(value, DESIGN_DOCUMENT_SCHEMA)
+    .map(({ path, detail }) => `${path}: ${detail}`);
+  if (errors.length > 0) return { ok: false, errors };
+
+  for (const field of ['frames', 'screens', 'flows', 'variants']) {
+    const seen = new Set();
+    for (const [index, item] of (value[field] ?? []).entries()) {
+      if (seen.has(item.id)) errors.push(`$.${field}[${index}].id: duplicate identity '${item.id}'`);
+      seen.add(item.id);
+    }
+  }
+
+  const screenIds = new Set(value.screens.map(({ id }) => id));
+  const orderedIds = new Set(value.screenOrder);
+  for (const id of value.screenOrder) {
+    if (!screenIds.has(id)) errors.push(`$.screenOrder: unknown screen '${id}'`);
+  }
+  for (const id of screenIds) {
+    if (!orderedIds.has(id)) errors.push(`$.screenOrder: missing screen '${id}'`);
+  }
+  for (const [index, flow] of (value.flows ?? []).entries()) {
+    for (const id of flow.screens) {
+      if (!screenIds.has(id)) errors.push(`$.flows[${index}].screens: unknown screen '${id}'`);
+    }
+  }
+  for (const [index, variant] of value.variants.entries()) {
+    for (const id of Object.keys(variant.sources ?? {})) {
+      if (!screenIds.has(id)) errors.push(`$.variants[${index}].sources: unknown screen '${id}'`);
+    }
+  }
+  const selected = value.variants.find(({ id }) => id === value.selectedVariant);
+  if (!selected) errors.push(`$.selectedVariant: unknown variant '${value.selectedVariant}'`);
+  else if (selected.status !== 'ready') errors.push('$.selectedVariant: selected variant must be ready');
+
+  for (const [index, spacing] of (value.designSystem?.spacing ?? []).entries()) {
+    if (!Number.isFinite(spacing)) errors.push(`$.designSystem.spacing[${index}]: expected a finite spacing value`);
+  }
+  return { ok: errors.length === 0, errors };
+}
+
+/** Return the original valid document; never normalize authored design intent. */
+export function assertDesignDocument(value) {
+  const result = validateDesignDocument(value);
+  if (!result.ok) throw new TypeError(`Invalid design document:\n${result.errors.join('\n')}`);
+  return value;
+}

package/src/design-publication-contracts.d.mts

@@ -0,0 +1,4 @@
+export declare const COMPANY_DESIGN_MAX_BYTES: number;
+export declare const COMPANY_DESIGN_MAX_ENTRIES: number;
+/** Validate the existing 1.1.0 review bundle for bounded company publication. */
+export declare function assertCompanyDesignBundle<T>(value: T): T;

package/src/design-publication-contracts.mjs

@@ -0,0 +1,85 @@
+/** Company publication constraints over the existing, compatible review bundle. */
+import { assertDesignReviewBundle } from './review-experience-contracts.mjs';
+import { canonicalizeJson, sha256Hex } from './canonical-json.mjs';
+
+export const COMPANY_DESIGN_MAX_BYTES = 1024 * 1024;
+export const COMPANY_DESIGN_MAX_ENTRIES = 256;
+const fail = message => { throw new TypeError(`Invalid company design bundle: ${message}`); };
+const isRecord = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const closed = (value, keys, label) => {
+  if (!isRecord(value) || Object.keys(value).some(key => !keys.includes(key))) fail(`${label} contains unsupported fields.`);
+};
+const boundedList = (value, max, label) => {
+  if (!Array.isArray(value) || !value.length || value.length > max) fail(`${label} must contain 1–${max} items.`);
+};
+const identities = (items, label) => {
+  const map = new Map();
+  for (const item of items) {
+    if (map.has(item.id)) fail(`${label} contains a duplicate identity.`);
+    map.set(item.id, item);
+  }
+  return map;
+};
+
+/** Pure browser/Worker-compatible validation; no artifact or design dependency. */
+export function assertCompanyDesignBundle(value) {
+  // Bound complexity before recursive schema validation/canonical serialization.
+  const pending = [[value, 0]];
+  let nodes = 0;
+  while (pending.length) {
+    const [item, depth] = pending.pop();
+    if (++nodes > 50000 || depth > 40) fail('document complexity exceeds the publication limit.');
+    if (item && typeof item === 'object') for (const child of Object.values(item)) pending.push([child, depth + 1]);
+  }
+  let serialized;
+  try { serialized = canonicalizeJson(value); } catch { fail('expected bounded JSON data.'); }
+  if (new TextEncoder().encode(serialized).byteLength > COMPANY_DESIGN_MAX_BYTES) fail('publication exceeds 1 MiB.');
+  if (value?.schemaVersion !== '1.1.0') fail('company publication requires review bundle version 1.1.0.');
+  assertDesignReviewBundle(value);
+  const { design, envelope, entries } = value;
+  boundedList(design.screens, 64, 'screens');
+  boundedList(design.frames, 16, 'frames');
+  boundedList(design.variants, 16, 'variants');
+  boundedList(entries, COMPANY_DESIGN_MAX_ENTRIES, 'entries');
+  const screens = identities(design.screens, 'screens');
+  const frames = identities(design.frames, 'frames');
+  const variants = identities(design.variants, 'variants');
+  if (design.variants.some(variant => variant.status !== 'ready') || !variants.has(design.selectedVariant)) fail('selected and published variants must be ready.');
+  if (design.screenOrder.length !== screens.size || design.screenOrder.some(id => !screens.has(id))) fail('screen order must identify every published screen.');
+  identities(design.flows ?? [], 'flows');
+  for (const flow of design.flows ?? []) if (flow.screens.some(id => !screens.has(id))) fail('flow references an unknown screen.');
+  if (screens.size * frames.size * variants.size !== entries.length) fail('entries must cover every screen, frame and ready variant.');
+  closed(envelope, ['schemaVersion', 'artifacts', 'viewer'], 'envelope');
+  if (envelope.schemaVersion !== '1.0.0') fail('unsupported envelope version.');
+  boundedList(envelope.artifacts, COMPANY_DESIGN_MAX_ENTRIES, 'artifacts');
+  const artifacts = identities(envelope.artifacts, 'artifacts');
+  if (artifacts.size !== entries.length) fail('entries and artifacts must correspond exactly.');
+  for (const artifact of artifacts.values()) {
+    closed(artifact, ['id', 'kind', 'title', 'html', 'sha256', 'viewport', 'colorScheme'], 'artifact');
+    if (typeof artifact.id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(artifact.id)) fail('artifact identity is invalid.');
+    if (artifact.kind !== 'html' || typeof artifact.title !== 'string' || !artifact.title.trim() || artifact.title.length > 512 || typeof artifact.html !== 'string' || !artifact.html.trim()) fail('artifacts must be titled HTML screens.');
+    closed(artifact.viewport, ['width', 'height'], 'viewport');
+    if (!['light', 'dark'].includes(artifact.colorScheme)) fail('artifact color scheme is invalid.');
+    if (artifact.sha256 !== sha256Hex(artifact.html.replace(/^\uFEFF/u, '').replace(/\r\n?/gu, '\n'))) fail('artifact digest does not match its HTML.');
+  }
+  const usedArtifacts = new Set(), combinations = new Set();
+  for (const entry of entries) {
+    const artifact = artifacts.get(entry.artifactId), frame = frames.get(entry.frameId);
+    if (!artifact || !frame || !screens.has(entry.screenId) || !variants.has(entry.variantId)) fail('entry references an unknown screen, variant, frame or artifact.');
+    const key = `${entry.screenId}:${entry.variantId}:${entry.frameId}`;
+    if (usedArtifacts.has(entry.artifactId) || combinations.has(key)) fail('entries must uniquely map artboards to artifacts.');
+    usedArtifacts.add(entry.artifactId); combinations.add(key);
+    if (artifact.viewport.width !== frame.width || artifact.viewport.height !== frame.height) fail('artifact viewport must match its declared frame.');
+  }
+  closed(envelope.viewer, ['mode', 'activeArtifactId', 'presentation'], 'viewer');
+  if (!['single', 'variants'].includes(envelope.viewer.mode) || !artifacts.has(envelope.viewer.activeArtifactId) || envelope.viewer.presentation !== 'canvas') fail('viewer must select a published canvas artifact.');
+  if (value.fingerprints.length !== entries.length) fail('fingerprints must cover every published artboard.');
+  for (const key of Object.keys(value.state?.positions ?? {})) if (!artifacts.has(key)) fail('layout references an unknown artifact.');
+  const components = identities(value.reviewContext.implementation.components, 'review components');
+  for (const component of components.values()) {
+    if (component.screenIds?.some(id => !screens.has(id))) fail('review guidance references an unknown screen.');
+    const anchors = new Set((component.screenIds?.length ? component.screenIds : design.screenOrder).flatMap(id => screens.get(id).anchors ?? []));
+    if (component.anchorIds?.some(id => !anchors.has(id))) fail('review guidance references an undeclared anchor.');
+  }
+  return value;
+}

package/src/diagram-contracts.d.mts

@@ -0,0 +1,19 @@
+export interface DiagramGrammarRegistryEntry extends Record<string, unknown> {
+  readonly grammarId: string;
+  readonly grammarVersion: '1.0.0';
+  readonly title: string;
+  readonly layoutFamily: string;
+  readonly aliases: readonly string[];
+  readonly requiredPrimitives: readonly string[];
+  readonly allowedPrimitives: readonly string[];
+}
+
+export declare const DIAGRAM_CONTRACT_FILES: Readonly<Record<string, string>>;
+export declare const DIAGRAM_GRAMMAR_REGISTRY: Readonly<{
+  grammars: readonly DiagramGrammarRegistryEntry[];
+  [key: string]: unknown;
+}>;
+export declare const DIAGRAM_SEMANTIC_PATTERN_REGISTRY: Readonly<Record<string, unknown>>;
+export declare function getDiagramGrammar(grammarId: string): DiagramGrammarRegistryEntry | null;
+export declare function diagramContractUrl(kind: string): URL;
+export declare function diagramDocumentPath(slug: string): string;

package/src/diagram-contracts.mjs

@@ -0,0 +1,28 @@
+import { DIAGRAM_V16_CONTRACT_FILES } from './skill-source-contracts.mjs';
+import { DIAGRAM_REGISTRIES } from './generated/diagram-registries.mjs';
+
+export const DIAGRAM_CONTRACT_FILES = DIAGRAM_V16_CONTRACT_FILES;
+export const DIAGRAM_GRAMMAR_REGISTRY = DIAGRAM_REGISTRIES['diagram-grammars.json'];
+export const DIAGRAM_SEMANTIC_PATTERN_REGISTRY = DIAGRAM_REGISTRIES['diagram-semantic-patterns.json'];
+
+const grammarIndex = new Map(
+  DIAGRAM_GRAMMAR_REGISTRY.grammars.map((grammar) => [grammar.grammarId, grammar]),
+);
+
+export function getDiagramGrammar(grammarId) {
+  return grammarIndex.get(grammarId) ?? null;
+}
+
+export function diagramContractUrl(kind) {
+  const filename = DIAGRAM_CONTRACT_FILES[kind];
+  if (!filename) throw new RangeError(`Unknown diagram contract: ${kind}@1.6.0`);
+  return new URL(`../schemas/v1.6.0/${filename}`, import.meta.url);
+}
+
+export function diagramDocumentPath(slug) {
+  const value = String(slug);
+  if (!/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u.test(value)) {
+    throw new TypeError(`Invalid diagram slug: ${value}`);
+  }
+  return `diagrams/${value}/${value}.planr-diagram.json`;
+}

package/src/enterprise-contracts.d.mts

@@ -0,0 +1,107 @@
+export type EnterpriseId = string;
+export type EnterpriseTimestamp = string;
+export type EnterpriseDigest = string;
+export type EnterpriseSchema = Readonly<Record<string, unknown>>;
+export type EnterpriseAction = 'organization.manage' | 'ownership.transfer' | 'billing.manage' | 'audit.read' | 'project.create' | 'project.manage' | 'artifact.read' | 'artifact.author' | 'artifact.export' | 'review.write' | 'review.resolve';
+export type EnterpriseProjectRole = 'maintainer' | 'author' | 'reviewer' | 'viewer';
+export type EnterpriseJson = null | boolean | number | string | EnterpriseJson[] | { [key: string]: EnterpriseJson };
+export interface EnterpriseScope { organizationId: EnterpriseId; projectId: EnterpriseId }
+export interface EnterpriseAccessContext {
+  actor: { id: EnterpriseId; verified: boolean };
+  organization: { id: EnterpriseId; status: 'active' | 'suspended' };
+  membership?: { organizationId: EnterpriseId; actorId: EnterpriseId; role: 'owner' | 'admin' | 'member'; status: 'active' | 'revoked' };
+  projectMembership?: EnterpriseScope & { actorId: EnterpriseId; role: EnterpriseProjectRole; status: 'active' | 'revoked' };
+  guestGrant?: EnterpriseScope & { artifactId: EnterpriseId; actorId: EnterpriseId; role: 'reviewer' | 'viewer'; status: 'active' | 'revoked'; expiresAt: EnterpriseTimestamp };
+  resource: { organizationId: EnterpriseId; projectId?: EnterpriseId; artifactId?: EnterpriseId };
+  action: EnterpriseAction;
+  now: EnterpriseTimestamp;
+}
+export interface EnterpriseAccessDecision { readonly allowed: boolean; readonly code: string }
+export interface EnterpriseArtifactRevision extends EnterpriseScope {
+  kind: 'openplanr-enterprise-artifact-revision'; schemaVersion: '1.0.0';
+  id: EnterpriseId; artifactId: EnterpriseId; parentRevisionId: EnterpriseId | null;
+  contentDigest: EnterpriseDigest; contentType: 'application/json' | 'text/markdown' | 'image/svg+xml' | 'text/html';
+  byteLength: number; createdAt: EnterpriseTimestamp; actorId: EnterpriseId;
+}
+export interface EnterpriseReviewAnchor {
+  revisionId: EnterpriseId; elementId?: EnterpriseId; screenId?: EnterpriseId; frameId?: EnterpriseId; x?: number; y?: number;
+}
+export interface EnterpriseReviewReply { id: EnterpriseId; authorId: EnterpriseId; body: string; createdAt: EnterpriseTimestamp }
+export type EnterpriseReviewCategory = 'question' | 'suggestion' | 'change-request' | 'blocker';
+export interface EnterpriseReviewThread extends EnterpriseScope {
+  kind: 'openplanr-enterprise-review-thread'; schemaVersion: '1.0.0';
+  id: EnterpriseId; artifactId: EnterpriseId; anchor: EnterpriseReviewAnchor;
+  category: EnterpriseReviewCategory; status: 'open' | 'addressed' | 'resolved';
+  authorId: EnterpriseId; body: string; createdAt: EnterpriseTimestamp; updatedAt: EnterpriseTimestamp;
+  replies: EnterpriseReviewReply[]; assigneeId?: EnterpriseId | null; addressedRevisionId?: EnterpriseId; resolvedAt?: EnterpriseTimestamp;
+}
+export type EnterpriseElementCollection = 'nodes' | 'relations' | 'groups' | 'events' | 'items';
+export type EnterpriseChangeOperation =
+  | { op: 'replace-document'; content: { [key: string]: EnterpriseJson } }
+  | { op: 'set-field'; targetId: EnterpriseId; field: 'label' | 'description' | 'status' | 'title'; value: string }
+  | { op: 'add-element'; collection: EnterpriseElementCollection; element: { id: EnterpriseId; [key: string]: EnterpriseJson } }
+  | { op: 'remove-element'; collection: EnterpriseElementCollection; targetId: EnterpriseId }
+  | { op: 'set-layout'; targetId: EnterpriseId; x: number; y: number };
+export interface EnterpriseChangeProposal extends EnterpriseScope {
+  kind: 'openplanr-enterprise-change-proposal'; schemaVersion: '1.0.0';
+  id: EnterpriseId; artifactId: EnterpriseId; baseRevisionId: EnterpriseId; authorId: EnterpriseId; createdAt: EnterpriseTimestamp;
+  status: 'draft' | 'proposed' | 'accepted' | 'rejected' | 'applied' | 'conflicted'; summary: string;
+  operations: EnterpriseChangeOperation[];
+  validation: { status: 'pending' | 'passed' | 'failed'; issues: { code: string; message: string; targetId?: EnterpriseId }[] };
+  application?: { revisionId: EnterpriseId; appliedAt: EnterpriseTimestamp; actorId: EnterpriseId; gitCommit?: string };
+}
+export type EnterpriseEvidenceSource =
+  | { kind: 'repository'; repositoryId: EnterpriseId; path: string; commit: string; line?: number }
+  | { kind: 'artifact'; artifactId: EnterpriseId; revisionId: EnterpriseId; elementId?: EnterpriseId }
+  | { kind: 'url'; url: string };
+export interface EnterpriseEvidenceReference extends EnterpriseScope {
+  kind: 'openplanr-enterprise-evidence-reference'; schemaVersion: '1.0.0'; id: EnterpriseId;
+  source: EnterpriseEvidenceSource; capturedAt: EnterpriseTimestamp; freshness: 'current' | 'stale' | 'unknown'; label: string; contentDigest?: EnterpriseDigest;
+}
+export interface EnterpriseSyncState extends EnterpriseScope {
+  kind: 'openplanr-enterprise-sync-state'; schemaVersion: '1.0.0'; repositoryId: EnterpriseId;
+  direction: 'push' | 'pull'; status: 'preview' | 'pending' | 'synchronized' | 'failed' | 'conflicted';
+  scope: EnterpriseId[]; cursor: string | null; operationId: EnterpriseId; updatedAt: EnterpriseTimestamp;
+  items: { artifactId: EnterpriseId; baseRevisionId: EnterpriseId | null; revisionId: EnterpriseId | null; contentDigest: EnterpriseDigest; action: 'create' | 'update' | 'unchanged' | 'conflict' }[];
+  issues: { code: string; artifactId?: EnterpriseId; message: string }[];
+}
+export interface EnterpriseAgentHandoff extends EnterpriseScope {
+  kind: 'openplanr-enterprise-agent-handoff'; schemaVersion: '1.0.0'; artifactId: EnterpriseId; revisionId: EnterpriseId;
+  generatedAt: EnterpriseTimestamp; authority: 'feedback-only'; contentTrust: 'untrusted';
+  threads: EnterpriseReviewThread[]; evidence: EnterpriseEvidenceReference[]; unresolvedUncertainties: string[]; contentDigest: EnterpriseDigest;
+}
+export declare const ENTERPRISE_CONTRACT_VERSION: '1.0.0';
+export declare const ENTERPRISE_PROTOCOL_VERSION: '1.12.0';
+export declare const ENTERPRISE_CONTENT_DIGEST_HEADER: 'X-OpenPlanr-Content-Digest';
+export declare const ENTERPRISE_ID_PATTERN: string;
+export declare const ENTERPRISE_REVIEW_CATEGORIES: readonly EnterpriseReviewCategory[];
+export declare const ENTERPRISE_ACTIONS: readonly EnterpriseAction[];
+export declare const ENTERPRISE_ACCESS_CONTEXT_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_ARTIFACT_REVISION_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_REVIEW_ANCHOR_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_REVIEW_THREAD_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_CHANGE_OPERATION_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_CHANGE_PROPOSAL_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_EVIDENCE_REFERENCE_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_SYNC_STATE_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_AGENT_HANDOFF_SCHEMA: EnterpriseSchema;
+export declare const ENTERPRISE_SCHEMAS: Readonly<Record<string, EnterpriseSchema>>;
+export declare function assertEnterpriseContract<T>(value: T, schemaOrName: EnterpriseSchema | string): T;
+export declare function assertEnterpriseRevision<T extends EnterpriseArtifactRevision>(value: T): T;
+export declare function assertEnterpriseRevisionAppend<T extends EnterpriseArtifactRevision>(revision: T, previous: EnterpriseArtifactRevision | null, content: string | Uint8Array): T;
+export declare function assertEnterpriseReviewThread<T extends EnterpriseReviewThread>(value: T): T;
+export declare function assertEnterpriseProposal<T extends EnterpriseChangeProposal>(value: T): T;
+export declare function assertEnterpriseEvidence<T extends EnterpriseEvidenceReference>(value: T): T;
+export declare function assertEnterpriseSync<T extends EnterpriseSyncState>(value: T): T;
+export declare function assertEnterpriseHandoff<T extends EnterpriseAgentHandoff>(value: T): T;
+export declare function isEnterpriseRepositoryPath(value: unknown): boolean;
+export declare function authorizeEnterpriseAccess(context: EnterpriseAccessContext): EnterpriseAccessDecision;
+/** Stable UI projection only; every resource request still requires server authorization. */
+export declare function enterpriseProjectCapabilities(role: EnterpriseProjectRole | string): readonly EnterpriseAction[];
+export declare function createEnterpriseHandoff(input: EnterpriseScope & { artifactId: EnterpriseId; revisionId: EnterpriseId; generatedAt: EnterpriseTimestamp; threads?: EnterpriseReviewThread[]; evidence?: EnterpriseEvidenceReference[]; unresolvedUncertainties?: string[] }): EnterpriseAgentHandoff;
+export declare function renderEnterpriseHandoffMarkdown(value: EnterpriseAgentHandoff): string;
+export interface EnterpriseLayout { [targetId: string]: { x: number; y: number } }
+export interface EnterpriseDocumentChange { op: 'add' | 'remove' | 'replace'; plane: 'semantic' | 'layout'; collection?: string; targetId?: string; field?: string; before?: EnterpriseJson; after?: EnterpriseJson }
+export interface EnterpriseDocumentDiff { semanticChanged: boolean; layoutChanged: boolean; changes: EnterpriseDocumentChange[] }
+export declare function diffEnterpriseDocuments(before: { [key: string]: EnterpriseJson }, after: { [key: string]: EnterpriseJson }, options?: { beforeLayout?: EnterpriseLayout; afterLayout?: EnterpriseLayout }): EnterpriseDocumentDiff;
+export declare function applyEnterpriseOperations(document: { [key: string]: EnterpriseJson }, proposal: EnterpriseChangeProposal, options?: { layout?: EnterpriseLayout }): EnterpriseDocumentDiff & { document: { [key: string]: EnterpriseJson }; layout: EnterpriseLayout };