@oatscenter/trellis 0.100.0-rc.1

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@oatscenter/trellis",
+  "description": "Client-side Trellis runtime, models, and participant helpers for TypeScript applications.",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./generated": {
+      "types": "./generated.d.ts",
+      "import": "./generated.js"
+    },
+    "./auth": {
+      "types": "./auth.d.ts",
+      "import": "./auth.js"
+    },
+    "./auth/browser": {
+      "types": "./auth/browser.d.ts",
+      "import": "./auth/browser.js"
+    },
+    "./device": {
+      "types": "./device.d.ts",
+      "import": "./device.js"
+    },
+    "./errors": {
+      "types": "./errors/index.d.ts",
+      "import": "./errors/index.js"
+    },
+    "./service": {
+      "types": "./service/mod.d.ts",
+      "import": "./service/mod.js"
+    },
+    "./telemetry": {
+      "types": "./telemetry.d.ts",
+      "import": "./telemetry.js"
+    }
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/exporter-metrics-otlp-proto": "^0.215.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.215.0",
+    "@opentelemetry/resources": "^2.7.0",
+    "@opentelemetry/sdk-metrics": "^2.7.0",
+    "@opentelemetry/sdk-trace-base": "^2.7.0",
+    "@opentelemetry/sdk-trace-node": "^2.7.0",
+    "@opentelemetry/semantic-conventions": "^1.40.0",
+    "@nats-io/jetstream": "^3.3.1",
+    "@nats-io/kv": "^3.3.1",
+    "@nats-io/obj": "^3.3.1",
+    "@nats-io/nats-core": "^3.3.1",
+    "@nats-io/nkeys": "^2.0.3",
+    "@nats-io/transport-node": "^3.3.1",
+    "@noble/curves": "^2.0.1",
+    "@noble/hashes": "1.8.0",
+    "@oatscenter/result": "0.100.0-rc.1",
+    "js-sha256": "^0.11.1",
+    "pino": "^10.3.1",
+    "tweetnacl": "^1.0.3",
+    "ts-deepmerge": "^7.0.3",
+    "typebox": "^1.1.33",
+    "ulid": "^3.0.2"
+  },
+  "version": "0.100.0-rc.1",
+  "type": "module",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OATS-Center/trellis.git"
+  }
+}

package/pagination.d.ts

@@ -0,0 +1,25 @@
+import { type AsyncResult, BaseError, type BaseErrorSchema, type Result } from "@oatscenter/result";
+import type { RequestOpts } from "./session.ts";
+type CursorPage<TItem> = Readonly<{
+    items: readonly TItem[];
+    page: Readonly<{
+        nextCursor?: string;
+    }>;
+}>;
+export type PaginationErrorData = BaseErrorSchema & {
+    type: "PaginationError";
+    cursor: string;
+};
+/** Failure caused by an invalid cursor sequence returned during pagination. */
+export declare class PaginationError extends BaseError<PaginationErrorData> {
+    readonly cursor: string;
+    readonly name: "PaginationError";
+    constructor(cursor: string);
+    toSerializable(): PaginationErrorData;
+}
+type CursorCall = (input: unknown, options?: RequestOpts) => AsyncResult<unknown, BaseError>;
+/** Lazily traverses complete pages from one cursor-paginated RPC. */
+export declare function cursorPages<TPage extends CursorPage<unknown>>(call: CursorCall, input?: unknown, options?: RequestOpts): AsyncIterable<Result<TPage, BaseError>>;
+/** Lazily traverses items from one cursor-paginated RPC. */
+export declare function cursorItems<TItem, TPage extends CursorPage<TItem>>(call: CursorCall, input?: unknown, options?: RequestOpts): AsyncIterable<Result<TItem, BaseError>>;
+export {};

package/pagination.js

@@ -0,0 +1,117 @@
+import { BaseError, err, ok, } from "@oatscenter/result";
+/** Failure caused by an invalid cursor sequence returned during pagination. */
+export class PaginationError extends BaseError {
+    cursor;
+    name = "PaginationError";
+    constructor(cursor) {
+        super("The paginated RPC returned a cursor that was already visited.", {
+            context: { cursor },
+        });
+        this.cursor = cursor;
+    }
+    toSerializable() {
+        return { ...this.baseSerializable(), type: this.name, cursor: this.cursor };
+    }
+}
+function pageIterator(call, input, options) {
+    let cursor;
+    let stopped = false;
+    let inFlight;
+    let serial = Promise.resolve();
+    const initialCursor = typeof input === "object" && input !== null &&
+        "page" in input && typeof input.page === "object" &&
+        input.page !== null &&
+        "cursor" in input.page && typeof input.page.cursor === "string" &&
+        input.page.cursor.length > 0
+        ? input.page.cursor
+        : undefined;
+    const seen = new Set(initialCursor === undefined ? [] : [initialCursor]);
+    const next = () => {
+        const result = serial.then(async () => {
+            if (stopped)
+                return { value: undefined, done: true };
+            const controller = new AbortController();
+            inFlight = controller;
+            const signal = options?.signal
+                ? AbortSignal.any([options.signal, controller.signal])
+                : controller.signal;
+            const requestInput = cursor === undefined ? input ?? {} : {
+                ...(typeof input === "object" && input !== null ? input : {}),
+                page: {
+                    ...(typeof input === "object" && input !== null &&
+                        "page" in input && typeof input.page === "object" &&
+                        input.page !== null
+                        ? input.page
+                        : {}),
+                    cursor,
+                },
+            };
+            const result = await call(requestInput, { ...options, signal });
+            if (inFlight === controller)
+                inFlight = undefined;
+            if (stopped)
+                return { value: undefined, done: true };
+            if (result.isErr()) {
+                stopped = true;
+                return { value: result, done: false };
+            }
+            const page = result.take();
+            const nextCursor = page.page.nextCursor;
+            if (nextCursor === undefined) {
+                stopped = true;
+            }
+            else if (seen.has(nextCursor)) {
+                stopped = true;
+                return { value: err(new PaginationError(nextCursor)), done: false };
+            }
+            else {
+                seen.add(nextCursor);
+                cursor = nextCursor;
+            }
+            return { value: ok(page), done: false };
+        });
+        serial = result.then(() => undefined, () => undefined);
+        return result;
+    };
+    return {
+        next,
+        async return() {
+            stopped = true;
+            inFlight?.abort();
+            return { value: undefined, done: true };
+        },
+    };
+}
+/** Lazily traverses complete pages from one cursor-paginated RPC. */
+export function cursorPages(call, input, options) {
+    return { [Symbol.asyncIterator]: () => pageIterator(call, input, options) };
+}
+/** Lazily traverses items from one cursor-paginated RPC. */
+export function cursorItems(call, input, options) {
+    return {
+        [Symbol.asyncIterator]() {
+            const pages = pageIterator(call, input, options);
+            let items = [][Symbol.iterator]();
+            return {
+                async next() {
+                    while (true) {
+                        const item = items.next();
+                        if (!item.done) {
+                            return { value: ok(item.value), done: false };
+                        }
+                        const page = await pages.next();
+                        if (page.done)
+                            return { value: undefined, done: true };
+                        if (page.value.isErr())
+                            return { value: page.value, done: false };
+                        items = page.value.orThrow().items[Symbol.iterator]();
+                    }
+                },
+                async return() {
+                    await pages.return?.();
+                    return { value: undefined, done: true };
+                },
+            };
+        },
+    };
+}

package/participant.d.ts

@@ -0,0 +1,6 @@
+export * from "./participant_runtime/api.ts";
+export * from "./participant_runtime/json.ts";
+export * from "./participant_runtime/metadata.ts";
+export * from "./participant_runtime/participant.ts";
+export * from "./participant_runtime/schemas.ts";
+export * from "./participant_runtime/surface_names.ts";

package/participant.js

@@ -0,0 +1,6 @@
+export * from "./participant_runtime/api.js";
+export * from "./participant_runtime/json.js";
+export * from "./participant_runtime/metadata.js";
+export * from "./participant_runtime/participant.js";
+export * from "./participant_runtime/schemas.js";
+export * from "./participant_runtime/surface_names.js";

package/participant_runtime/api.d.ts

@@ -0,0 +1,131 @@
+import type { StaticDecode, TSchema } from "typebox";
+import type { BaseError } from "@oatscenter/result";
+import type { Codec } from "../generated.ts";
+type SubjectParam = `/${string}`;
+/** Encodes one exact generated event descriptor identity for signed metadata. */
+export declare function eventDescriptorIdentity(apiId: string, eventName: string, parameterCount: number): string;
+/** Derives one deployment-bound API request subject. */
+export declare function boundApiSubject(family: "rpc" | "operation" | "feed", apiId: string, providerDeploymentId: string, action: string): string;
+/** Derives one API-qualified event subject template. */
+export declare function eventSubject(apiId: string, action: string): string;
+/** Derives an owner control subscription or an exact subject for one Feed instance. */
+export declare function feedControlSubject(feedSubject: string, ownerInstanceId: string, feedId?: string): string;
+/** Derives the stable queue shared by replicas subscribed to an exact route. */
+export declare function routeQueueGroup(subject: string): string;
+export type Schema<T> = {
+    schema: unknown;
+    readonly __trellisType?: T;
+};
+export type SchemaLike<T = unknown> = TSchema | Schema<T> | Codec<T>;
+export type SerializableErrorData = {
+    id: string;
+    type: string;
+    message: string;
+    context?: Record<string, unknown>;
+    traceId?: string;
+} & Record<string, unknown>;
+export type RpcErrorClass<TData extends SerializableErrorData = SerializableErrorData, TError extends BaseError = BaseError> = {
+    fromSerializable(data: TData): TError;
+};
+export type RuntimeRpcErrorDesc<TType extends string = string, TSchema extends SchemaLike | undefined = SchemaLike | undefined, TError extends BaseError = BaseError> = {
+    type: TType;
+    schema?: TSchema;
+    fromSerializable(data: TSchema extends SchemaLike ? InferSchemaType<TSchema> : SerializableErrorData): TError;
+};
+export type InferRuntimeRpcError<T extends RuntimeRpcErrorDesc> = T extends RuntimeRpcErrorDesc<string, SchemaLike | undefined, infer TError> ? TError : never;
+export type InferSchemaType<S> = S extends Schema<infer T> ? T : S extends {
+    decode(value: unknown): infer T;
+} ? T : S extends TSchema ? StaticDecode<S> : unknown;
+export declare function schema<T>(raw: unknown): Schema<T>;
+export declare function unwrapSchema(raw: SchemaLike): unknown;
+/** Exact permission metadata for one contract API surface action. */
+export type PermissionAtom = Readonly<{
+    /** Source API semantic identity. */
+    apiId: string;
+    /** Version of the source API surface. */
+    apiVersion: `v${number}`;
+    /** API surface family. */
+    surfaceKind: "rpc" | "operation" | "event" | "feed" | "state";
+    /** Exact API-local surface name. */
+    surfaceName: string;
+    /** Exact action required for the surface. */
+    action: "call" | "invoke" | "observe" | "cancel" | "control" | "publish" | "subscribe" | "read" | "write" | "delete" | "submit" | "process" | "consume";
+}>;
+export type RPCDesc<I extends SchemaLike = SchemaLike, O extends SchemaLike = SchemaLike, E extends readonly string[] | undefined = readonly string[] | undefined, TRuntimeErrors extends readonly RuntimeRpcErrorDesc[] | undefined = readonly RuntimeRpcErrorDesc[] | undefined> = {
+    subject: string;
+    input: I;
+    output: O;
+    /** Exact permission required to call this RPC. */
+    permission: PermissionAtom;
+    callerCapabilities: readonly string[];
+    transfer?: {
+        direction: "receive";
+    };
+    authRequired?: boolean;
+    errors?: E;
+    runtimeErrors?: TRuntimeErrors;
+    declaredErrorTypes?: readonly string[];
+};
+export type EventDesc<S extends SchemaLike = SchemaLike> = {
+    subject: string;
+    /** Canonical API, event, and parameter-shape identity bound into proofs. */
+    descriptorIdentity: string;
+    params?: readonly SubjectParam[];
+    event: S;
+    /** Exact permission required to publish this event. */
+    publishPermission: PermissionAtom;
+    /** Exact permission required to subscribe to this event. */
+    subscribePermission: PermissionAtom;
+    publishCapabilities: readonly string[];
+    subscribeCapabilities: readonly string[];
+};
+export type FeedDesc<I extends SchemaLike = SchemaLike, E extends SchemaLike = SchemaLike> = {
+    subject: string;
+    input: I;
+    event: E;
+    /** Exact permission required to subscribe to this feed. */
+    permission: PermissionAtom;
+    subscribeCapabilities: readonly string[];
+};
+export type OperationDesc<I extends SchemaLike = SchemaLike, P extends SchemaLike | undefined = SchemaLike | undefined, O extends SchemaLike | undefined = SchemaLike | undefined, E extends readonly string[] | undefined = readonly string[] | undefined, TRuntimeErrors extends readonly RuntimeRpcErrorDesc[] | undefined = readonly RuntimeRpcErrorDesc[] | undefined, U extends SchemaLike | undefined = SchemaLike | undefined> = {
+    subject: string;
+    input: I;
+    progress?: P;
+    update?: U;
+    output?: O;
+    /** Exact permissions required by each operation action. */
+    permissions: Readonly<{
+        invoke: PermissionAtom;
+        observe: PermissionAtom;
+        cancel: PermissionAtom;
+        control: Readonly<Record<string, PermissionAtom>>;
+    }>;
+    errors?: E;
+    runtimeErrors?: TRuntimeErrors;
+    declaredErrorTypes?: readonly string[];
+    transfer?: {
+        direction: "send";
+        store?: string;
+        key?: `/${string}`;
+        contentType?: `/${string}`;
+        metadata?: `/${string}`;
+        expiresInMs?: number;
+        maxBytes?: number;
+    };
+    signals?: Record<string, {
+        input: SchemaLike;
+    }>;
+    callerCapabilities: readonly string[];
+    observeCapabilities: readonly string[];
+    cancelCapabilities: readonly string[];
+    controlCapabilities: readonly string[];
+    cancel?: boolean;
+};
+export type RuntimeApi = {
+    rpc: Record<string, RPCDesc>;
+    operations: Record<string, OperationDesc>;
+    events: Record<string, EventDesc>;
+    feeds?: Record<string, FeedDesc>;
+    subjects: Record<string, unknown>;
+};
+export {};

package/participant_runtime/api.js

@@ -0,0 +1,42 @@
+import { sha256Base64urlSync } from "./json.js";
+function subjectToken(value) {
+    return btoa(String.fromCharCode(...new TextEncoder().encode(value)))
+        .replaceAll("+", "-")
+        .replaceAll("/", "_")
+        .replace(/=+$/u, "");
+}
+/** Encodes one exact generated event descriptor identity for signed metadata. */
+export function eventDescriptorIdentity(apiId, eventName, parameterCount) {
+    if (!Number.isSafeInteger(parameterCount) || parameterCount < 0) {
+        throw new Error("event parameter count must be a non-negative safe integer");
+    }
+    return `v1.${subjectToken(apiId)}.${subjectToken(eventName)}.${parameterCount}`;
+}
+/** Derives one deployment-bound API request subject. */
+export function boundApiSubject(family, apiId, providerDeploymentId, action) {
+    return `${family}.v1.${subjectToken(apiId)}.${subjectToken(providerDeploymentId)}.${action}`;
+}
+/** Derives one API-qualified event subject template. */
+export function eventSubject(apiId, action) {
+    return `events.v1.${subjectToken(apiId)}.${action}`;
+}
+/** Derives an owner control subscription or an exact subject for one Feed instance. */
+export function feedControlSubject(feedSubject, ownerInstanceId, feedId) {
+    const ownerSubject = `${feedSubject}.control.${subjectToken(ownerInstanceId)}`;
+    return feedId === undefined
+        ? `${ownerSubject}.*`
+        : `${ownerSubject}.${subjectToken(feedId)}`;
+}
+/** Derives the stable queue shared by replicas subscribed to an exact route. */
+export function routeQueueGroup(subject) {
+    return `trellis.${sha256Base64urlSync(subject)}`;
+}
+export function schema(raw) {
+    return { schema: raw };
+}
+export function unwrapSchema(raw) {
+    if (raw && typeof raw === "object" && "schema" in raw) {
+        return raw.schema;
+    }
+    return raw;
+}

package/participant_runtime/json.d.ts

@@ -0,0 +1,16 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [k: string]: JsonValue;
+};
+export declare function isJsonValue(value: unknown): value is JsonValue;
+export declare function canonicalizeJson(value: JsonValue): string;
+export declare function base64url(bytes: Uint8Array): string;
+export declare function sha256Bytes(data: Uint8Array): Uint8Array;
+/** Computes a synchronous SHA-256 digest encoded as base64url. */
+export declare function sha256Base64urlSync(text: string): string;
+/** Computes a SHA-256 digest encoded as base64url. */
+export declare function sha256Base64url(text: string): Promise<string>;
+/** Canonicalizes JSON and computes its SHA-256 base64url digest. */
+export declare function digestJson(value: JsonValue): Promise<{
+    canonical: string;
+    digest: string;
+}>;

package/participant_runtime/json.js

@@ -0,0 +1,193 @@
+export function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean")
+        return true;
+    if (typeof value === "number") {
+        return Number.isFinite(value) && !Object.is(value, -0);
+    }
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (typeof value === "object") {
+        return Object.values(value).every(isJsonValue);
+    }
+    return false;
+}
+export function canonicalizeJson(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`Non-canonical number in manifest: ${value}`);
+        }
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalizeJson).join(",")}]`;
+    }
+    const keys = Object.keys(value).sort();
+    const entries = keys.map((k) => `${JSON.stringify(k)}:${canonicalizeJson(value[k])}`);
+    return `{${entries.join(",")}}`;
+}
+export function base64url(bytes) {
+    let bin = "";
+    for (const b of bytes)
+        bin += String.fromCharCode(b);
+    const b64 = btoa(bin);
+    return b64.replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+}
+function rotr(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+export function sha256Bytes(data) {
+    const K = new Uint32Array([
+        0x428a2f98,
+        0x71374491,
+        0xb5c0fbcf,
+        0xe9b5dba5,
+        0x3956c25b,
+        0x59f111f1,
+        0x923f82a4,
+        0xab1c5ed5,
+        0xd807aa98,
+        0x12835b01,
+        0x243185be,
+        0x550c7dc3,
+        0x72be5d74,
+        0x80deb1fe,
+        0x9bdc06a7,
+        0xc19bf174,
+        0xe49b69c1,
+        0xefbe4786,
+        0x0fc19dc6,
+        0x240ca1cc,
+        0x2de92c6f,
+        0x4a7484aa,
+        0x5cb0a9dc,
+        0x76f988da,
+        0x983e5152,
+        0xa831c66d,
+        0xb00327c8,
+        0xbf597fc7,
+        0xc6e00bf3,
+        0xd5a79147,
+        0x06ca6351,
+        0x14292967,
+        0x27b70a85,
+        0x2e1b2138,
+        0x4d2c6dfc,
+        0x53380d13,
+        0x650a7354,
+        0x766a0abb,
+        0x81c2c92e,
+        0x92722c85,
+        0xa2bfe8a1,
+        0xa81a664b,
+        0xc24b8b70,
+        0xc76c51a3,
+        0xd192e819,
+        0xd6990624,
+        0xf40e3585,
+        0x106aa070,
+        0x19a4c116,
+        0x1e376c08,
+        0x2748774c,
+        0x34b0bcb5,
+        0x391c0cb3,
+        0x4ed8aa4a,
+        0x5b9cca4f,
+        0x682e6ff3,
+        0x748f82ee,
+        0x78a5636f,
+        0x84c87814,
+        0x8cc70208,
+        0x90befffa,
+        0xa4506ceb,
+        0xbef9a3f7,
+        0xc67178f2,
+    ]);
+    const H = new Uint32Array([
+        0x6a09e667,
+        0xbb67ae85,
+        0x3c6ef372,
+        0xa54ff53a,
+        0x510e527f,
+        0x9b05688c,
+        0x1f83d9ab,
+        0x5be0cd19,
+    ]);
+    const bitLength = data.length * 8;
+    const paddedLength = Math.ceil((data.length + 9) / 64) * 64;
+    const padded = new Uint8Array(paddedLength);
+    padded.set(data);
+    padded[data.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(paddedLength - 4, bitLength >>> 0, false);
+    view.setUint32(paddedLength - 8, Math.floor(bitLength / 2 ** 32), false);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < padded.length; offset += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = view.getUint32(offset + i * 4, false);
+        }
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^
+                (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (((w[i - 16] + s0) | 0) + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, h] = H;
+        for (let i = 0; i < 64; i++) {
+            const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const temp1 = (((((h + s1) | 0) + ch) | 0) + K[i] + w[i]) >>> 0;
+            const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const temp2 = (s0 + maj) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temp1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temp1 + temp2) >>> 0;
+        }
+        H[0] = (H[0] + a) >>> 0;
+        H[1] = (H[1] + b) >>> 0;
+        H[2] = (H[2] + c) >>> 0;
+        H[3] = (H[3] + d) >>> 0;
+        H[4] = (H[4] + e) >>> 0;
+        H[5] = (H[5] + f) >>> 0;
+        H[6] = (H[6] + g) >>> 0;
+        H[7] = (H[7] + h) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const outView = new DataView(out.buffer);
+    for (let i = 0; i < H.length; i++) {
+        outView.setUint32(i * 4, H[i], false);
+    }
+    return out;
+}
+/** Computes a synchronous SHA-256 digest encoded as base64url. */
+export function sha256Base64urlSync(text) {
+    return base64url(sha256Bytes(new TextEncoder().encode(text)));
+}
+/** Computes a SHA-256 digest encoded as base64url. */
+export async function sha256Base64url(text) {
+    if (typeof crypto !== "undefined" && crypto.subtle) {
+        const data = new TextEncoder().encode(text);
+        const digest = await crypto.subtle.digest("SHA-256", data);
+        return base64url(new Uint8Array(digest));
+    }
+    return sha256Base64urlSync(text);
+}
+/** Canonicalizes JSON and computes its SHA-256 base64url digest. */
+export async function digestJson(value) {
+    const canonical = canonicalizeJson(value);
+    const digest = await sha256Base64url(canonical);
+    return { canonical, digest };
+}

package/participant_runtime/metadata.d.ts

@@ -0,0 +1,34 @@
+import type { KvRepresentation } from "../kv.ts";
+import type { SchemaLike } from "./api.ts";
+export declare const PARTICIPANT_JOBS_METADATA: unique symbol;
+export declare const PARTICIPANT_KV_METADATA: unique symbol;
+export declare const PARTICIPANT_STORE_METADATA: unique symbol;
+export declare const PARTICIPANT_EVENT_CONSUMERS_METADATA: unique symbol;
+export type ParticipantJobsMetadata = Record<string, {
+    payload: unknown;
+    update?: unknown;
+    updateSchema?: SchemaLike;
+    result: unknown;
+}>;
+export type ParticipantKvMetadata = Record<string, {
+    required: boolean;
+    value: unknown;
+    schema: KvRepresentation<unknown>;
+}>;
+export type ParticipantStoreMetadata = Record<string, {
+    required: boolean;
+}>;
+export type TrellisValidationIssueHint = {
+    code: string;
+    message: string;
+    note?: string;
+    label?: string;
+    i18nKey?: string;
+    severity?: "error" | "warning" | "info";
+};
+export type TrellisValidationExtension = {
+    label?: string;
+    note?: string;
+    uiPath?: string;
+    issues?: Record<string, TrellisValidationIssueHint>;
+};

package/participant_runtime/metadata.js

@@ -0,0 +1,4 @@
+export const PARTICIPANT_JOBS_METADATA = Symbol.for("@oatscenter/trellis/participant/jobs");
+export const PARTICIPANT_KV_METADATA = Symbol.for("@oatscenter/trellis/participant/kv");
+export const PARTICIPANT_STORE_METADATA = Symbol.for("@oatscenter/trellis/participant/store");
+export const PARTICIPANT_EVENT_CONSUMERS_METADATA = Symbol.for("@oatscenter/trellis/participant/event-consumers");