@treeseed/sdk 0.13.0-rc.11 → 0.13.0-rc.111

package/dist/security/encrypted-envelope.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+export declare const encryptedEnvelopeAadSchema: z.ZodObject<{
+    purpose: z.ZodString;
+    teamId: z.ZodOptional<z.ZodString>;
+    resourceType: z.ZodString;
+    resourceId: z.ZodString;
+    topicId: z.ZodOptional<z.ZodString>;
+    sendId: z.ZodOptional<z.ZodString>;
+    invocationId: z.ZodOptional<z.ZodString>;
+    assignmentId: z.ZodOptional<z.ZodString>;
+    sequence: z.ZodOptional<z.ZodNumber>;
+    eventType: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: string;
+    purpose: string;
+    resourceType: string;
+    resourceId: string;
+    teamId?: string | undefined;
+    assignmentId?: string | undefined;
+    topicId?: string | undefined;
+    sendId?: string | undefined;
+    invocationId?: string | undefined;
+    sequence?: number | undefined;
+    eventType?: string | undefined;
+}, {
+    schemaVersion: string;
+    purpose: string;
+    resourceType: string;
+    resourceId: string;
+    teamId?: string | undefined;
+    assignmentId?: string | undefined;
+    topicId?: string | undefined;
+    sendId?: string | undefined;
+    invocationId?: string | undefined;
+    sequence?: number | undefined;
+    eventType?: string | undefined;
+}>;
+export declare const encryptedEnvelopeSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.encrypted-envelope/v1">;
+    algorithm: z.ZodLiteral<"aes-256-gcm">;
+    keyProvider: z.ZodString;
+    keyId: z.ZodString;
+    keyVersion: z.ZodNumber;
+    wrappedDek: z.ZodObject<{
+        nonce: z.ZodString;
+        authenticationTag: z.ZodString;
+        ciphertext: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    }, {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    }>;
+    payload: z.ZodObject<{
+        nonce: z.ZodString;
+        authenticationTag: z.ZodString;
+        ciphertext: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    }, {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    }>;
+    aad: z.ZodObject<{
+        purpose: z.ZodString;
+        teamId: z.ZodOptional<z.ZodString>;
+        resourceType: z.ZodString;
+        resourceId: z.ZodString;
+        topicId: z.ZodOptional<z.ZodString>;
+        sendId: z.ZodOptional<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
+        assignmentId: z.ZodOptional<z.ZodString>;
+        sequence: z.ZodOptional<z.ZodNumber>;
+        eventType: z.ZodOptional<z.ZodString>;
+        schemaVersion: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        schemaVersion: string;
+        purpose: string;
+        resourceType: string;
+        resourceId: string;
+        teamId?: string | undefined;
+        assignmentId?: string | undefined;
+        topicId?: string | undefined;
+        sendId?: string | undefined;
+        invocationId?: string | undefined;
+        sequence?: number | undefined;
+        eventType?: string | undefined;
+    }, {
+        schemaVersion: string;
+        purpose: string;
+        resourceType: string;
+        resourceId: string;
+        teamId?: string | undefined;
+        assignmentId?: string | undefined;
+        topicId?: string | undefined;
+        sendId?: string | undefined;
+        invocationId?: string | undefined;
+        sequence?: number | undefined;
+        eventType?: string | undefined;
+    }>;
+    aadDigest: z.ZodString;
+    ciphertextDigest: z.ZodString;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.encrypted-envelope/v1";
+    createdAt: string;
+    algorithm: "aes-256-gcm";
+    keyProvider: string;
+    keyId: string;
+    keyVersion: number;
+    wrappedDek: {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    };
+    payload: {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    };
+    aad: {
+        schemaVersion: string;
+        purpose: string;
+        resourceType: string;
+        resourceId: string;
+        teamId?: string | undefined;
+        assignmentId?: string | undefined;
+        topicId?: string | undefined;
+        sendId?: string | undefined;
+        invocationId?: string | undefined;
+        sequence?: number | undefined;
+        eventType?: string | undefined;
+    };
+    aadDigest: string;
+    ciphertextDigest: string;
+}, {
+    schemaVersion: "treeseed.encrypted-envelope/v1";
+    createdAt: string;
+    algorithm: "aes-256-gcm";
+    keyProvider: string;
+    keyId: string;
+    keyVersion: number;
+    wrappedDek: {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    };
+    payload: {
+        nonce: string;
+        authenticationTag: string;
+        ciphertext: string;
+    };
+    aad: {
+        schemaVersion: string;
+        purpose: string;
+        resourceType: string;
+        resourceId: string;
+        teamId?: string | undefined;
+        assignmentId?: string | undefined;
+        topicId?: string | undefined;
+        sendId?: string | undefined;
+        invocationId?: string | undefined;
+        sequence?: number | undefined;
+        eventType?: string | undefined;
+    };
+    aadDigest: string;
+    ciphertextDigest: string;
+}>;
+export type EncryptedEnvelopeAad = z.infer<typeof encryptedEnvelopeAadSchema>;
+export type EncryptedEnvelope = z.infer<typeof encryptedEnvelopeSchema>;

package/dist/security/encrypted-envelope.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+const base64Url = z.string().min(1).regex(/^[A-Za-z0-9_-]+$/u);
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const identifier = z.string().regex(/^[a-z][a-z0-9._-]{0,127}$/u);
+const encryptedEnvelopeAadSchema = z.object({
+  purpose: identifier,
+  teamId: z.string().min(1).max(256).optional(),
+  resourceType: identifier,
+  resourceId: z.string().min(1).max(512),
+  topicId: z.string().min(1).max(256).optional(),
+  sendId: z.string().min(1).max(256).optional(),
+  invocationId: z.string().min(1).max(256).optional(),
+  assignmentId: z.string().min(1).max(256).optional(),
+  sequence: z.number().int().nonnegative().optional(),
+  eventType: z.string().min(1).max(256).optional(),
+  schemaVersion: z.string().min(1).max(128)
+}).strict();
+const encryptedEnvelopeSchema = z.object({
+  schemaVersion: z.literal("treeseed.encrypted-envelope/v1"),
+  algorithm: z.literal("aes-256-gcm"),
+  keyProvider: identifier,
+  keyId: identifier,
+  keyVersion: z.number().int().positive(),
+  wrappedDek: z.object({ nonce: base64Url, authenticationTag: base64Url, ciphertext: base64Url }).strict(),
+  payload: z.object({ nonce: base64Url, authenticationTag: base64Url, ciphertext: base64Url }).strict(),
+  aad: encryptedEnvelopeAadSchema,
+  aadDigest: digest,
+  ciphertextDigest: digest,
+  createdAt: z.string().datetime()
+}).strict();
+export {
+  encryptedEnvelopeAadSchema,
+  encryptedEnvelopeSchema
+};

package/dist/security/envelope-codec.d.ts

@@ -0,0 +1,38 @@
+import { type EncryptedEnvelope, type EncryptedEnvelopeAad } from './encrypted-envelope.js';
+export interface EnvelopeKeyProvider {
+    readonly id: string;
+    active(): {
+        id: string;
+        version: number;
+        key: Uint8Array;
+    };
+    resolve(id: string, version: number): Uint8Array | undefined;
+}
+export declare class EncryptedEnvelopeCodec {
+    private readonly keys;
+    constructor(keys: EnvelopeKeyProvider);
+    encrypt(plaintext: Uint8Array | string, aad: EncryptedEnvelopeAad): EncryptedEnvelope;
+    decrypt(input: EncryptedEnvelope): Buffer;
+    authenticate(input: EncryptedEnvelope): boolean;
+    rewrap(input: EncryptedEnvelope): EncryptedEnvelope;
+}
+export declare class StaticEnvelopeKeyProvider implements EnvelopeKeyProvider {
+    private readonly activeKey;
+    private readonly historical;
+    readonly id: string;
+    constructor(id: string, activeKey: {
+        id: string;
+        version: number;
+        key: Uint8Array;
+    }, historical?: Array<{
+        id: string;
+        version: number;
+        key: Uint8Array;
+    }>);
+    active(): {
+        id: string;
+        version: number;
+        key: Uint8Array;
+    };
+    resolve(id: string, version: number): Uint8Array<ArrayBufferLike> | undefined;
+}

package/dist/security/envelope-codec.js

@@ -0,0 +1,96 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+import { encryptedEnvelopeSchema } from "./encrypted-envelope.js";
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+const digest = (value) => `sha256:${createHash("sha256").update(value).digest("hex")}`;
+const encode = (value) => Buffer.from(value).toString("base64url");
+const decode = (value) => {
+  const decoded = Buffer.from(value, "base64url");
+  if (decoded.toString("base64url") !== value) throw new Error("Encrypted envelope contains a non-canonical base64url value.");
+  return decoded;
+};
+function seal(key, plaintext, aad) {
+  if (key.byteLength !== 32) throw new Error("Envelope keys must contain exactly 32 bytes.");
+  const nonce = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", key, nonce);
+  cipher.setAAD(Buffer.from(aad));
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  return { nonce: encode(nonce), authenticationTag: encode(cipher.getAuthTag()), ciphertext: encode(ciphertext) };
+}
+function open(key, value, aad) {
+  const decipher = createDecipheriv("aes-256-gcm", key, decode(value.nonce));
+  decipher.setAAD(Buffer.from(aad));
+  decipher.setAuthTag(decode(value.authenticationTag));
+  return Buffer.concat([decipher.update(decode(value.ciphertext)), decipher.final()]);
+}
+class EncryptedEnvelopeCodec {
+  constructor(keys) {
+    this.keys = keys;
+  }
+  keys;
+  encrypt(plaintext, aad) {
+    const active = this.keys.active();
+    const aadValue = canonical(aad);
+    const dek = randomBytes(32);
+    const payload = seal(dek, typeof plaintext === "string" ? Buffer.from(plaintext) : plaintext, aadValue);
+    const wrappedDek = seal(active.key, dek, `${aadValue}:dek`);
+    return encryptedEnvelopeSchema.parse({
+      schemaVersion: "treeseed.encrypted-envelope/v1",
+      algorithm: "aes-256-gcm",
+      keyProvider: this.keys.id,
+      keyId: active.id,
+      keyVersion: active.version,
+      wrappedDek,
+      payload,
+      aad,
+      aadDigest: digest(aadValue),
+      ciphertextDigest: digest(decode(payload.ciphertext)),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  decrypt(input) {
+    const envelope = encryptedEnvelopeSchema.parse(input);
+    const aad = canonical(envelope.aad);
+    if (digest(aad) !== envelope.aadDigest || digest(decode(envelope.payload.ciphertext)) !== envelope.ciphertextDigest) throw new Error("Encrypted envelope digest verification failed.");
+    const key = this.keys.resolve(envelope.keyId, envelope.keyVersion);
+    if (!key) throw new Error(`Encrypted envelope key ${envelope.keyId}:${envelope.keyVersion} is unavailable.`);
+    const dek = open(key, envelope.wrappedDek, `${aad}:dek`);
+    return open(dek, envelope.payload, aad);
+  }
+  authenticate(input) {
+    this.decrypt(input);
+    return true;
+  }
+  rewrap(input) {
+    const envelope = encryptedEnvelopeSchema.parse(input);
+    const prior = this.keys.resolve(envelope.keyId, envelope.keyVersion);
+    if (!prior) throw new Error(`Encrypted envelope key ${envelope.keyId}:${envelope.keyVersion} is unavailable.`);
+    const aad = canonical(envelope.aad);
+    const dek = open(prior, envelope.wrappedDek, `${aad}:dek`);
+    const active = this.keys.active();
+    return encryptedEnvelopeSchema.parse({ ...envelope, keyProvider: this.keys.id, keyId: active.id, keyVersion: active.version, wrappedDek: seal(active.key, dek, `${aad}:dek`) });
+  }
+}
+class StaticEnvelopeKeyProvider {
+  constructor(id, activeKey, historical = []) {
+    this.activeKey = activeKey;
+    this.historical = historical;
+    this.id = id;
+  }
+  activeKey;
+  historical;
+  id;
+  active() {
+    return this.activeKey;
+  }
+  resolve(id, version) {
+    return [this.activeKey, ...this.historical].find((entry) => entry.id === id && entry.version === version)?.key;
+  }
+}
+export {
+  EncryptedEnvelopeCodec,
+  StaticEnvelopeKeyProvider
+};

package/dist/security/index.d.ts

@@ -0,0 +1,2 @@
+export * from './encrypted-envelope.js';
+export * from './envelope-codec.js';

package/dist/security/index.js

@@ -0,0 +1,2 @@
+export * from "./encrypted-envelope.js";
+export * from "./envelope-codec.js";

package/dist/site-contracts/catalog.d.ts

@@ -0,0 +1,16 @@
+export declare const REMOTE_CONTRACT_HEADER = "x-treeseed-contract-version";
+export declare const REMOTE_CONTRACT_VERSION = 1;
+export declare const COMMERCE_OFFER_MODES: readonly ["free", "private", "contact", "one_time", "one_time_current_version", "subscription", "subscription_updates", "professional_hosting", "scoped_contract", "external"];
+export type CommerceOfferMode = typeof COMMERCE_OFFER_MODES[number];
+export type CatalogItemOfferMode = CommerceOfferMode;
+export interface CatalogItem {
+    id?: string;
+    slug: string;
+    name?: string;
+    title?: string;
+    description?: string;
+    visibility?: string;
+    offerMode?: CommerceOfferMode;
+    priceModel?: CommerceOfferMode;
+    [key: string]: any;
+}

package/dist/site-contracts/catalog.js

@@ -0,0 +1,19 @@
+const REMOTE_CONTRACT_HEADER = "x-treeseed-contract-version";
+const REMOTE_CONTRACT_VERSION = 1;
+const COMMERCE_OFFER_MODES = [
+  "free",
+  "private",
+  "contact",
+  "one_time",
+  "one_time_current_version",
+  "subscription",
+  "subscription_updates",
+  "professional_hosting",
+  "scoped_contract",
+  "external"
+];
+export {
+  COMMERCE_OFFER_MODES,
+  REMOTE_CONTRACT_HEADER,
+  REMOTE_CONTRACT_VERSION
+};

package/dist/site-contracts/cloudflare.d.ts

@@ -0,0 +1,48 @@
+export interface KvNamespacePutOptions {
+    expirationTtl?: number;
+}
+export interface KvNamespaceLike {
+    get(key: string): Promise<string | null>;
+    put(key: string, value: string, options?: KvNamespacePutOptions): Promise<void>;
+}
+export interface D1PreparedStatementLike {
+    bind(...values: unknown[]): D1PreparedStatementLike;
+    run(): Promise<unknown>;
+    first<T = Record<string, unknown>>(): Promise<T | null>;
+    all<T = Record<string, unknown>>(): Promise<{
+        results: T[];
+    }>;
+    raw<T = unknown[]>(): Promise<T[]>;
+}
+export interface D1DatabaseLike {
+    prepare(query: string): D1PreparedStatementLike;
+    batch?(statements: D1PreparedStatementLike[]): Promise<unknown[]>;
+    exec?(query: string): Promise<unknown>;
+}
+export interface CloudflareRuntimeAssets {
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export interface R2ObjectLike {
+    text(): Promise<string>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    json<T = unknown>(): Promise<T>;
+    httpEtag?: string;
+    etag?: string;
+    size?: number;
+    uploaded?: Date;
+    writeHttpMetadata?(headers: Headers): void;
+}
+export interface R2BucketLike {
+    get(key: string): Promise<R2ObjectLike | null>;
+    head?(key: string): Promise<R2ObjectLike | null>;
+    put(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: Record<string, unknown>): Promise<unknown>;
+    delete?(key: string | string[]): Promise<void>;
+}
+export interface CloudflareRuntime {
+    env: {
+        FORM_GUARD_KV: KvNamespaceLike;
+        SITE_DATA_DB: D1DatabaseLike;
+        ASSETS?: CloudflareRuntimeAssets;
+        [key: string]: unknown;
+    };
+}

package/dist/site-contracts/platform.d.ts

@@ -0,0 +1,94 @@
+export type ContentCollection = 'pages' | 'notes' | 'questions' | 'objectives' | 'proposals' | 'decisions' | 'people' | 'agents' | 'books' | 'docs' | 'templates' | 'workdays' | 'groups' | 'group_edges';
+export type ThemeMode = 'light' | 'dark' | 'system';
+export type ColorSchemeId = 'fern' | 'lichen' | 'cedar' | 'tidepool' | (string & {});
+export interface SemanticColorTokens {
+    canvas: string;
+    canvasSubtle: string;
+    surface: string;
+    surfaceMuted: string;
+    surfaceRaised: string;
+    surfaceOverlay: string;
+    text: string;
+    textMuted: string;
+    textSubtle: string;
+    textInverse: string;
+    link: string;
+    linkHover: string;
+    border: string;
+    borderMuted: string;
+    borderStrong: string;
+    focus: string;
+    accent: string;
+    accentHover: string;
+    accentStrong: string;
+    accentSoft: string;
+    accentText: string;
+    info: string;
+    infoSoft: string;
+    infoText: string;
+    infoBorder: string;
+    success: string;
+    successSoft: string;
+    successText: string;
+    successBorder: string;
+    warning: string;
+    warningSoft: string;
+    warningText: string;
+    warningBorder: string;
+    danger: string;
+    dangerSoft: string;
+    dangerText: string;
+    dangerBorder: string;
+    shadow: string;
+    grid: string;
+}
+export interface SchemeTokens {
+    light: SemanticColorTokens;
+    dark: SemanticColorTokens;
+}
+export interface ThemeConfig {
+    defaultScheme?: ColorSchemeId;
+    defaultMode?: ThemeMode;
+    schemes?: Record<string, Partial<{
+        light: Partial<SemanticColorTokens>;
+        dark: Partial<SemanticColorTokens>;
+    }>>;
+}
+export type PlatformSurfaceName = 'web' | 'api' | (string & {});
+export type PlatformResourceKind = 'pages' | 'styles' | 'components' | 'routes' | 'middleware' | 'handlers' | 'config';
+export interface PlatformLayerDefinition {
+    root: string;
+    kinds?: PlatformResourceKind[];
+}
+export interface ManagedServiceEnvironmentConfig {
+    baseUrl?: string;
+    domain?: string;
+    serviceName?: string;
+    [key: string]: unknown;
+}
+export interface DeployConfig {
+    content?: Record<string, unknown>;
+    forms?: Record<string, unknown>;
+    surfaces?: Record<string, unknown>;
+    services?: Record<string, unknown>;
+    [key: string]: any;
+}
+export interface TenantConfig {
+    id?: string;
+    name?: string;
+    root?: string;
+    content: Record<string, string | undefined>;
+    features?: Record<string, boolean | undefined>;
+    site?: {
+        models?: Partial<Record<ContentCollection, {
+            rendered?: boolean;
+        }>>;
+    };
+    theme?: ThemeConfig;
+    plugins?: Array<{
+        package: string;
+        enabled?: boolean;
+        config?: Record<string, unknown>;
+    }>;
+    [key: string]: any;
+}

package/dist/site-contracts/plugin.d.ts

@@ -0,0 +1,63 @@
+import type { DeployConfig, PlatformLayerDefinition, PlatformResourceKind, PlatformSurfaceName, TenantConfig } from './platform.js';
+export type RouteOwner = 'market' | 'admin' | 'core';
+export type RouteResponseKind = 'page' | 'message' | 'redirect' | 'data' | 'proxy' | 'action' | 'feed';
+export type RouteArchetype = 'action' | 'auth-form' | 'collection' | 'dashboard' | 'detail' | 'feed' | 'message' | 'profile' | 'reader' | 'redirect' | 'settings' | 'wizard';
+export type RouteNavigationPosture = 'primary' | 'secondary' | 'contextual' | 'hidden';
+export type RouteStatus = 'active' | 'planned' | 'deprecated';
+export interface RouteCapability {
+    id: string;
+    owner: RouteOwner;
+    responseKind: RouteResponseKind;
+    archetype: RouteArchetype;
+    shell: string;
+    template: string;
+    surface: 'auth' | 'public' | 'personal' | 'team' | 'content' | 'system';
+    resourceType: string;
+    accessPolicy: string[];
+    viewModelDependencies: string[];
+    navigation: RouteNavigationPosture;
+    states: Array<'loading' | 'empty' | 'forbidden' | 'unavailable' | 'validation' | 'conflict' | 'retry' | 'success' | 'not-found'>;
+    selector: string;
+    status: RouteStatus;
+    guarantees: string[];
+    description: string;
+    knowledgePageIds?: string[];
+}
+export interface SiteRouteContribution {
+    pattern: string;
+    entrypoint?: string;
+    resourcePath?: string;
+    capability?: RouteCapability;
+}
+export interface SiteExtensionContribution {
+    routes?: SiteRouteContribution[];
+    starlightComponents?: Record<string, string>;
+    customCss?: string[];
+    remarkPlugins?: unknown[];
+    rehypePlugins?: unknown[];
+    envSchema?: Record<string, unknown>;
+    vitePlugins?: unknown[];
+    integrations?: unknown[];
+    routeMiddleware?: unknown[];
+}
+export interface PluginSiteContext {
+    projectRoot: string;
+    tenantConfig: TenantConfig;
+    deployConfig?: DeployConfig;
+    pluginConfig: Record<string, unknown>;
+}
+export interface Plugin {
+    id?: string;
+    provides?: Record<string, unknown>;
+    siteProviders?: Record<string, SiteExtensionContribution | ((context: PluginSiteContext) => SiteExtensionContribution)>;
+    siteHooks?: SiteExtensionContribution | ((context: PluginSiteContext) => SiteExtensionContribution);
+    siteLayers?: PlatformLayerDefinition[] | ((context: PluginSiteContext) => PlatformLayerDefinition[] | undefined);
+    platformLayers?: Array<PlatformLayerDefinition & {
+        surface?: PlatformSurfaceName;
+        kinds?: PlatformResourceKind[];
+    }>;
+    [key: string]: unknown;
+}
+export declare function defineRoute<T extends SiteRouteContribution>(route: T): T;
+export declare function validateRouteCapabilities(routes: readonly SiteRouteContribution[]): readonly SiteRouteContribution[];
+export declare function definePlugin<T extends Plugin>(plugin: T): T;

package/dist/site-contracts/plugin.js

@@ -0,0 +1,26 @@
+function defineRoute(route) {
+  if (!route.pattern.startsWith("/")) throw new Error(`TreeSeed route pattern must start with "/": ${route.pattern}`);
+  if (route.capability && !/^[a-z][a-z0-9.-]+$/u.test(route.capability.id)) throw new Error(`Invalid TreeSeed route capability id: ${route.capability.id}`);
+  return route;
+}
+function validateRouteCapabilities(routes) {
+  const patterns = /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    defineRoute(route);
+    if (patterns.has(route.pattern)) throw new Error(`Duplicate TreeSeed route pattern: ${route.pattern}`);
+    patterns.add(route.pattern);
+    if (!route.capability) throw new Error(`TreeSeed route ${route.pattern} is missing capability metadata.`);
+    if (ids.has(route.capability.id)) throw new Error(`Duplicate TreeSeed route capability id: ${route.capability.id}`);
+    ids.add(route.capability.id);
+  }
+  return routes;
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+export {
+  definePlugin,
+  defineRoute,
+  validateRouteCapabilities
+};

package/dist/treeai/catalog.d.ts

@@ -0,0 +1 @@
+export * from '../operator-contracts/catalog/treeai-operations.js';

package/dist/treeai/catalog.js

@@ -0,0 +1 @@
+export * from "../operator-contracts/catalog/treeai-operations.js";