@treeseed/sdk 0.1.1

package/dist/src/model-registry.d.ts

@@ -0,0 +1,4 @@
+import type { SdkModelDefinition, SdkModelName } from './sdk-types.ts';
+export declare function buildModelRegistry(): Record<SdkModelName, SdkModelDefinition>;
+export declare const MODEL_REGISTRY: Record<SdkModelName, SdkModelDefinition>;
+export declare function resolveModelDefinition(model: string): SdkModelDefinition;

package/dist/src/runtime.d.ts

@@ -0,0 +1 @@
+export declare function resolveSdkRepoRoot(repoRoot?: string): string;

package/dist/src/sdk-filters.d.ts

@@ -0,0 +1,4 @@
+import type { SdkContentEntry, SdkFilterCondition, SdkSortSpec } from './sdk-types.ts';
+export declare function matchesFilter(entry: SdkContentEntry | Record<string, unknown>, filter: SdkFilterCondition): boolean;
+export declare function applyFilters<T extends SdkContentEntry | Record<string, unknown>>(items: T[], filters?: SdkFilterCondition[]): T[];
+export declare function applySort<T extends SdkContentEntry | Record<string, unknown>>(items: T[], sort?: SdkSortSpec[]): T[];

package/dist/src/sdk-types.d.ts

@@ -0,0 +1,285 @@
+export declare const SDK_MODEL_NAMES: readonly ["page", "note", "question", "book", "knowledge", "objective", "person", "subscription", "message", "agent", "agent_run", "agent_cursor", "content_lease"];
+export declare const SDK_OPERATIONS: readonly ["get", "read", "search", "follow", "pick", "create", "update"];
+export declare const SDK_STORAGE_BACKENDS: readonly ["content", "d1"];
+export declare const SDK_PICK_STRATEGIES: readonly ["latest", "highest_priority", "oldest"];
+export type SdkModelName = (typeof SDK_MODEL_NAMES)[number];
+export type SdkOperation = (typeof SDK_OPERATIONS)[number];
+export type SdkStorageBackend = (typeof SDK_STORAGE_BACKENDS)[number];
+export type SdkPickStrategy = (typeof SDK_PICK_STRATEGIES)[number];
+export type SdkFilterOperator = 'eq' | 'in' | 'contains' | 'prefix' | 'gt' | 'gte' | 'lt' | 'lte' | 'updated_since' | 'related_to';
+export type TreeseedSchemaVersion = number;
+export type TreeseedRuntimeRecordType = 'subscription' | 'contact_submission' | 'agent_run' | 'message' | 'agent_cursor' | 'content_lease';
+export interface TreeseedRecordEnvelope<TPayload, TMeta = Record<string, unknown>> {
+    recordType: TreeseedRuntimeRecordType;
+    schemaVersion: TreeseedSchemaVersion;
+    status: string;
+    payload: TPayload;
+    meta: TMeta;
+}
+export interface TreeseedSubscriptionPayload {
+    email: string;
+    name: string | null;
+    source: string;
+    consentAt: string | null;
+    ipHash: string;
+}
+export interface TreeseedSubscriptionMeta {
+    legacyId?: number;
+}
+export interface TreeseedContactSubmissionPayload {
+    name: string;
+    email: string;
+    organization: string | null;
+    contactType: string;
+    subject: string;
+    message: string;
+    userAgent: string;
+    ipHash: string;
+}
+export interface TreeseedContactSubmissionMeta {
+    source?: string;
+}
+export interface TreeseedAgentRunPayload {
+    triggerSource: string;
+    handlerKind?: string | null;
+    triggerKind?: string | null;
+    selectedItemKey: string | null;
+    selectedMessageId: number | null;
+    claimedMessageId?: number | null;
+    branchName: string | null;
+    prUrl: string | null;
+    summary: string | null;
+    error: string | null;
+    errorCategory?: string | null;
+    commitSha?: string | null;
+    changedPaths?: string[];
+    finishedAt: string | null;
+}
+export interface TreeseedAgentRunMeta {
+    runId: string;
+    agentSlug: string;
+}
+export interface TreeseedMessagePayload {
+    body: Record<string, unknown>;
+}
+export interface TreeseedMessageMeta {
+    actor?: string;
+    trace?: Record<string, unknown>;
+}
+export interface TreeseedCursorPayload {
+    cursorValue: string;
+}
+export interface TreeseedCursorMeta {
+    updatedBy?: string;
+}
+export interface TreeseedLeasePayload {
+    token: string;
+}
+export interface TreeseedLeaseMeta {
+    actor?: string;
+}
+export interface SdkFilterCondition {
+    field: string;
+    op: SdkFilterOperator;
+    value: unknown;
+}
+export interface SdkSortSpec {
+    field: string;
+    direction?: 'asc' | 'desc';
+}
+export interface SdkJsonEnvelope<TPayload> {
+    ok: boolean;
+    model: SdkModelName;
+    operation: SdkOperation;
+    payload: TPayload;
+    meta?: Record<string, unknown>;
+}
+export interface SdkMessageEntity {
+    [key: string]: unknown;
+    id: number;
+    recordType?: TreeseedRuntimeRecordType;
+    schemaVersion?: TreeseedSchemaVersion;
+    type: string;
+    status: string;
+    payloadJson: string;
+    metaJson?: string;
+    relatedModel: string | null;
+    relatedId: string | null;
+    priority: number;
+    availableAt: string;
+    claimedBy: string | null;
+    claimedAt: string | null;
+    leaseExpiresAt: string | null;
+    attempts: number;
+    maxAttempts: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SdkRunEntity {
+    [key: string]: unknown;
+    runId: string;
+    recordType?: TreeseedRuntimeRecordType;
+    schemaVersion?: TreeseedSchemaVersion;
+    agentSlug: string;
+    handlerKind?: string | null;
+    triggerKind?: string | null;
+    triggerSource: string;
+    claimedMessageId?: number | null;
+    status: string;
+    selectedItemKey: string | null;
+    selectedMessageId: number | null;
+    branchName: string | null;
+    commitSha?: string | null;
+    changedPaths?: string[];
+    prUrl: string | null;
+    summary: string | null;
+    error: string | null;
+    errorCategory?: string | null;
+    startedAt: string;
+    finishedAt: string | null;
+}
+export interface SdkCursorEntity {
+    [key: string]: unknown;
+    recordType?: TreeseedRuntimeRecordType;
+    schemaVersion?: TreeseedSchemaVersion;
+    agentSlug: string;
+    cursorKey: string;
+    cursorValue: string;
+    updatedAt: string | null;
+}
+export interface SdkLeaseEntity {
+    [key: string]: unknown;
+    recordType?: TreeseedRuntimeRecordType;
+    schemaVersion?: TreeseedSchemaVersion;
+    model: string;
+    itemKey: string;
+    claimedBy: string;
+    claimedAt: string;
+    leaseExpiresAt: string;
+    token: string;
+}
+export interface SdkSubscriptionEntity {
+    [key: string]: unknown;
+    id?: number;
+    recordType?: TreeseedRuntimeRecordType;
+    schemaVersion?: TreeseedSchemaVersion;
+    email: string;
+    name?: string | null;
+    status: string;
+    source?: string;
+    metaJson?: string;
+    consent_at?: string;
+    created_at?: string;
+    updated_at?: string;
+    ip_hash?: string;
+}
+export interface SdkAgentSpec {
+    [key: string]: unknown;
+    id: string;
+    slug: string;
+    title?: string;
+    body: string;
+    frontmatter: Record<string, unknown>;
+}
+export interface SdkContentEntry {
+    id: string;
+    slug: string;
+    model: SdkModelName;
+    title?: string;
+    path: string;
+    body: string;
+    frontmatter: Record<string, unknown>;
+    updatedAt: string | null;
+    createdAt: string | null;
+}
+export interface SdkSearchRequest {
+    model: SdkModelName;
+    filters?: SdkFilterCondition[];
+    sort?: SdkSortSpec[];
+    limit?: number;
+    cursor?: string | null;
+}
+export interface SdkGetRequest {
+    model: SdkModelName;
+    id?: string;
+    slug?: string;
+    key?: string;
+}
+export interface SdkFollowRequest {
+    model: SdkModelName;
+    since: string;
+    filters?: SdkFilterCondition[];
+    timeoutSeconds?: number;
+}
+export interface SdkPickRequest {
+    model: SdkModelName;
+    strategy?: SdkPickStrategy;
+    filters?: SdkFilterCondition[];
+    leaseSeconds: number;
+    workerId: string;
+}
+export interface SdkMutationRequest {
+    model: SdkModelName;
+    data: Record<string, unknown>;
+    actor: string;
+}
+export interface SdkUpdateRequest extends SdkMutationRequest {
+    id?: string;
+    slug?: string;
+    key?: string;
+    expectedVersion?: string;
+}
+export interface SdkModelDefinition {
+    name: SdkModelName;
+    aliases: string[];
+    storage: SdkStorageBackend;
+    operations: SdkOperation[];
+    filterableFields: string[];
+    sortableFields: string[];
+    pickField: string;
+    contentCollection?: string;
+    contentDir?: string;
+}
+export interface SdkCreateMessageRequest {
+    type: string;
+    payload: Record<string, unknown>;
+    relatedModel?: string | null;
+    relatedId?: string | null;
+    priority?: number;
+    maxAttempts?: number;
+    actor: string;
+}
+export interface SdkClaimMessageRequest {
+    workerId: string;
+    messageTypes?: string[];
+    leaseSeconds: number;
+}
+export interface SdkAckMessageRequest {
+    id: number;
+    status: 'completed' | 'failed' | 'dead_letter' | 'pending' | 'claimed';
+}
+export interface SdkRecordRunRequest {
+    run: Record<string, unknown>;
+}
+export interface SdkCursorRequest {
+    agentSlug: string;
+    cursorKey: string;
+    cursorValue: string;
+}
+export interface SdkGetCursorRequest {
+    agentSlug: string;
+    cursorKey: string;
+}
+export interface SdkLeaseReleaseRequest {
+    model: string;
+    itemKey: string;
+    leaseToken?: string | null;
+}
+export interface SdkFollowResult<TItem> {
+    items: TItem[];
+    since: string;
+}
+export interface SdkPickResult<TItem> {
+    item: TItem | null;
+    leaseToken: string | null;
+}

package/dist/src/sdk.d.ts

@@ -0,0 +1,109 @@
+import type { AgentPermissionConfig, AgentRuntimeSpec } from './types/agents.ts';
+import { ContentStore } from './content-store.ts';
+import { type AgentDatabase } from './d1-store.ts';
+import type { SdkAckMessageRequest, SdkClaimMessageRequest, SdkCreateMessageRequest, SdkCursorRequest, SdkFollowRequest, SdkGetRequest, SdkGetCursorRequest, SdkJsonEnvelope, SdkLeaseReleaseRequest, SdkMutationRequest, SdkPickRequest, SdkRecordRunRequest, SdkSearchRequest, SdkUpdateRequest } from './sdk-types.ts';
+export interface AgentSdkOptions {
+    repoRoot?: string;
+    database?: AgentDatabase;
+}
+export declare class AgentSdk {
+    readonly database: AgentDatabase;
+    readonly content: ContentStore;
+    constructor(options?: AgentSdkOptions);
+    static createLocal(options: {
+        repoRoot?: string;
+        databaseName?: string;
+        persistTo?: string;
+    }): AgentSdk;
+    private envelope;
+    get(request: SdkGetRequest): Promise<SdkJsonEnvelope<Record<string, unknown> | import("./sdk-types.ts").SdkContentEntry | null>>;
+    read(request: SdkGetRequest): Promise<{
+        operation: "read";
+        ok: boolean;
+        model: import("./sdk-types.ts").SdkModelName;
+        payload: Record<string, unknown> | import("./sdk-types.ts").SdkContentEntry | null;
+        meta?: Record<string, unknown>;
+    }>;
+    search(request: SdkSearchRequest): Promise<SdkJsonEnvelope<Record<string, unknown>[] | import("./sdk-types.ts").SdkContentEntry[]>>;
+    follow(request: SdkFollowRequest): Promise<SdkJsonEnvelope<{
+        items: Record<string, unknown>[];
+        since: string;
+    } | {
+        items: import("./sdk-types.ts").SdkContentEntry[];
+        since: string;
+    }>>;
+    pick(request: SdkPickRequest): Promise<SdkJsonEnvelope<import("./sdk-types.ts").SdkPickResult<Record<string, unknown>> | import("./sdk-types.ts").SdkPickResult<import("./sdk-types.ts").SdkContentEntry>>>;
+    create(request: SdkMutationRequest): Promise<SdkJsonEnvelope<Record<string, unknown> | {
+        item: import("./sdk-types.ts").SdkContentEntry;
+        git: import("./git-runtime.ts").GitMutationResult;
+    }>>;
+    update(request: SdkUpdateRequest): Promise<SdkJsonEnvelope<Record<string, unknown> | {
+        item: import("./sdk-types.ts").SdkContentEntry;
+        git: import("./git-runtime.ts").GitMutationResult;
+    } | null>>;
+    claimMessage(request: SdkClaimMessageRequest): Promise<SdkJsonEnvelope<import("./sdk-types.ts").SdkMessageEntity | null>>;
+    ackMessage(request: SdkAckMessageRequest): Promise<SdkJsonEnvelope<{
+        id: number;
+        status: "pending" | "claimed" | "completed" | "failed" | "dead_letter";
+    }>>;
+    createMessage(request: SdkCreateMessageRequest): Promise<SdkJsonEnvelope<import("./sdk-types.ts").SdkMessageEntity>>;
+    recordRun(request: SdkRecordRunRequest): Promise<SdkJsonEnvelope<Record<string, unknown>>>;
+    getCursor(request: SdkGetCursorRequest): Promise<SdkJsonEnvelope<string | null>>;
+    upsertCursor(request: SdkCursorRequest): Promise<SdkJsonEnvelope<SdkCursorRequest>>;
+    releaseLease(request: SdkLeaseReleaseRequest): Promise<SdkJsonEnvelope<SdkLeaseReleaseRequest>>;
+    releaseAllLeases(): Promise<SdkJsonEnvelope<{
+        count: number;
+    }>>;
+    listAgentSpecs(options?: {
+        enabled?: boolean;
+    }): Promise<AgentRuntimeSpec[]>;
+    listRawAgentSpecs(options?: {
+        enabled?: boolean;
+    }): Promise<Record<string, unknown>[] | import("./sdk-types.ts").SdkContentEntry[]>;
+    scopeForAgent(agent: Pick<AgentRuntimeSpec, 'slug' | 'permissions'>): ScopedAgentSdk;
+}
+export declare class ScopedAgentSdk {
+    private readonly base;
+    private readonly actor;
+    private readonly permissions;
+    constructor(base: AgentSdk, actor: string, permissions: AgentPermissionConfig[]);
+    private assertAllowed;
+    get(request: SdkGetRequest): Promise<SdkJsonEnvelope<Record<string, unknown> | import("./sdk-types.ts").SdkContentEntry | null>>;
+    read(request: SdkGetRequest): Promise<{
+        operation: "read";
+        ok: boolean;
+        model: import("./sdk-types.ts").SdkModelName;
+        payload: Record<string, unknown> | import("./sdk-types.ts").SdkContentEntry | null;
+        meta?: Record<string, unknown>;
+    }>;
+    search(request: SdkSearchRequest): Promise<SdkJsonEnvelope<Record<string, unknown>[] | import("./sdk-types.ts").SdkContentEntry[]>>;
+    follow(request: SdkFollowRequest): Promise<SdkJsonEnvelope<{
+        items: Record<string, unknown>[];
+        since: string;
+    } | {
+        items: import("./sdk-types.ts").SdkContentEntry[];
+        since: string;
+    }>>;
+    pick(request: SdkPickRequest): Promise<SdkJsonEnvelope<import("./sdk-types.ts").SdkPickResult<Record<string, unknown>> | import("./sdk-types.ts").SdkPickResult<import("./sdk-types.ts").SdkContentEntry>>>;
+    create(request: Omit<SdkMutationRequest, 'actor'>): Promise<SdkJsonEnvelope<Record<string, unknown> | {
+        item: import("./sdk-types.ts").SdkContentEntry;
+        git: import("./git-runtime.ts").GitMutationResult;
+    }>>;
+    update(request: Omit<SdkUpdateRequest, 'actor'>): Promise<SdkJsonEnvelope<Record<string, unknown> | {
+        item: import("./sdk-types.ts").SdkContentEntry;
+        git: import("./git-runtime.ts").GitMutationResult;
+    } | null>>;
+    claimMessage(request: SdkClaimMessageRequest): Promise<SdkJsonEnvelope<import("./sdk-types.ts").SdkMessageEntity | null>>;
+    ackMessage(request: SdkAckMessageRequest): Promise<SdkJsonEnvelope<{
+        id: number;
+        status: "pending" | "claimed" | "completed" | "failed" | "dead_letter";
+    }>>;
+    createMessage(request: Omit<SdkCreateMessageRequest, 'actor'>): Promise<SdkJsonEnvelope<import("./sdk-types.ts").SdkMessageEntity>>;
+    recordRun(request: SdkRecordRunRequest): Promise<SdkJsonEnvelope<Record<string, unknown>>>;
+    getCursor(request: SdkGetCursorRequest): Promise<SdkJsonEnvelope<string | null>>;
+    upsertCursor(request: SdkCursorRequest): Promise<SdkJsonEnvelope<SdkCursorRequest>>;
+    releaseLease(request: SdkLeaseReleaseRequest): Promise<SdkJsonEnvelope<SdkLeaseReleaseRequest>>;
+    releaseAllLeases(): Promise<SdkJsonEnvelope<{
+        count: number;
+    }>>;
+}

package/dist/src/stores/cursor-store.d.ts

@@ -0,0 +1,10 @@
+import type { SdkCursorEntity, SdkCursorRequest, SdkGetCursorRequest, SdkSearchRequest, SdkUpdateRequest } from '../sdk-types.ts';
+import { SqliteStoreBase } from './helpers.ts';
+export declare class CursorStore extends SqliteStoreBase {
+    private usesEnvelopeTable;
+    getByKey(key: string): Promise<SdkCursorEntity | null>;
+    get(request: SdkGetCursorRequest): Promise<string | null>;
+    search(request: SdkSearchRequest): Promise<SdkCursorEntity[]>;
+    upsert(request: SdkCursorRequest): Promise<void>;
+    update(request: SdkUpdateRequest): Promise<SdkCursorEntity | null>;
+}

package/dist/src/stores/envelopes.d.ts

@@ -0,0 +1,116 @@
+import type { SdkCursorEntity, SdkLeaseEntity, SdkMessageEntity, SdkRunEntity, SdkSubscriptionEntity, TreeseedAgentRunMeta, TreeseedAgentRunPayload, TreeseedContactSubmissionMeta, TreeseedContactSubmissionPayload, TreeseedCursorMeta, TreeseedCursorPayload, TreeseedLeaseMeta, TreeseedLeasePayload, TreeseedMessageMeta, TreeseedMessagePayload, TreeseedRecordEnvelope, TreeseedSubscriptionMeta, TreeseedSubscriptionPayload } from '../sdk-types.ts';
+export declare const TRESEED_ENVELOPE_SCHEMA_VERSION = 1;
+export interface RuntimeRecordRow {
+    id?: number;
+    record_type?: string;
+    record_key?: string | null;
+    lookup_key?: string | null;
+    secondary_key?: string | null;
+    status?: string;
+    schema_version?: number;
+    created_at?: string;
+    updated_at?: string;
+    payload_json?: string;
+    meta_json?: string;
+}
+export interface MessageQueueRow {
+    id?: number;
+    message_type?: string;
+    status?: string;
+    schema_version?: number;
+    related_model?: string | null;
+    related_id?: string | null;
+    priority?: number;
+    available_at?: string;
+    claimed_by?: string | null;
+    claimed_at?: string | null;
+    lease_expires_at?: string | null;
+    attempts?: number;
+    max_attempts?: number;
+    created_at?: string;
+    updated_at?: string;
+    payload_json?: string;
+    meta_json?: string;
+}
+export interface CursorStateRow {
+    agent_slug?: string;
+    cursor_key?: string;
+    status?: string;
+    schema_version?: number;
+    updated_at?: string;
+    payload_json?: string;
+    meta_json?: string;
+}
+export interface LeaseStateRow {
+    model?: string;
+    item_key?: string;
+    status?: string;
+    schema_version?: number;
+    claimed_by?: string | null;
+    claimed_at?: string | null;
+    lease_expires_at?: string | null;
+    created_at?: string;
+    updated_at?: string;
+    payload_json?: string;
+    meta_json?: string;
+}
+export declare function createSubscriptionEnvelope(input: {
+    email: string;
+    name?: string | null;
+    status?: string;
+    source?: string;
+    consentAt?: string | null;
+    ipHash?: string;
+    meta?: TreeseedSubscriptionMeta;
+}): TreeseedRecordEnvelope<TreeseedSubscriptionPayload, TreeseedSubscriptionMeta>;
+export declare function subscriptionEntityFromEnvelope(row: RuntimeRecordRow): SdkSubscriptionEntity;
+export declare function createContactSubmissionEnvelope(input: {
+    name: string;
+    email: string;
+    organization?: string | null;
+    contactType: string;
+    subject: string;
+    message: string;
+    userAgent: string;
+    ipHash: string;
+    meta?: TreeseedContactSubmissionMeta;
+}): TreeseedRecordEnvelope<TreeseedContactSubmissionPayload, TreeseedContactSubmissionMeta>;
+export declare function createMessageEnvelope(input: {
+    type: string;
+    payload: Record<string, unknown>;
+    meta?: TreeseedMessageMeta;
+}): TreeseedRecordEnvelope<TreeseedMessagePayload, TreeseedMessageMeta>;
+export declare function messageEntityFromEnvelope(row: MessageQueueRow): SdkMessageEntity;
+export declare function createRunEnvelope(input: {
+    runId: string;
+    agentSlug: string;
+    status: string;
+    triggerSource: string;
+    startedAt: string;
+    handlerKind?: string | null;
+    triggerKind?: string | null;
+    selectedItemKey?: string | null;
+    selectedMessageId?: number | null;
+    claimedMessageId?: number | null;
+    branchName?: string | null;
+    prUrl?: string | null;
+    summary?: string | null;
+    error?: string | null;
+    errorCategory?: string | null;
+    commitSha?: string | null;
+    changedPaths?: string[];
+    finishedAt?: string | null;
+}): TreeseedRecordEnvelope<TreeseedAgentRunPayload, TreeseedAgentRunMeta>;
+export declare function runEntityFromEnvelope(row: RuntimeRecordRow): SdkRunEntity;
+export declare function createCursorEnvelope(input: {
+    agentSlug: string;
+    cursorKey: string;
+    cursorValue: string;
+    meta?: TreeseedCursorMeta;
+}): TreeseedRecordEnvelope<TreeseedCursorPayload, TreeseedCursorMeta>;
+export declare function cursorEntityFromEnvelope(row: CursorStateRow): SdkCursorEntity;
+export declare function createLeaseEnvelope(input: {
+    token: string;
+    meta?: TreeseedLeaseMeta;
+}): TreeseedRecordEnvelope<TreeseedLeasePayload, TreeseedLeaseMeta>;
+export declare function leaseEntityFromEnvelope(row: LeaseStateRow): SdkLeaseEntity;

package/dist/src/stores/helpers.d.ts

@@ -0,0 +1,12 @@
+import type { D1DatabaseLike } from '../types/cloudflare.ts';
+export type DatabaseRow = Record<string, unknown>;
+export declare function nowIso(): string;
+export declare function toSqlValue(value: unknown): string;
+export declare class SqliteStoreBase {
+    protected readonly db: D1DatabaseLike;
+    constructor(db: D1DatabaseLike);
+    protected selectAll(query: string): Promise<DatabaseRow[]>;
+    protected selectFirst(query: string): Promise<DatabaseRow | null>;
+    protected execute(query: string): Promise<void>;
+    protected tableExists(tableName: string): Promise<boolean>;
+}

package/dist/src/stores/lease-store.d.ts

@@ -0,0 +1,18 @@
+import type { SdkLeaseEntity, SdkLeaseReleaseRequest, SdkSearchRequest, SdkUpdateRequest } from '../sdk-types.ts';
+import { SqliteStoreBase } from './helpers.ts';
+export interface LeaseClaimInput {
+    model: string;
+    itemKey: string;
+    claimedBy: string;
+    leaseSeconds: number;
+}
+export declare class LeaseStore extends SqliteStoreBase {
+    private usesEnvelopeTable;
+    getByKey(key: string): Promise<SdkLeaseEntity | null>;
+    search(request: SdkSearchRequest): Promise<SdkLeaseEntity[]>;
+    tryClaim(input: LeaseClaimInput): Promise<`${string}-${string}-${string}-${string}-${string}` | null>;
+    create(input: LeaseClaimInput): Promise<SdkLeaseEntity | null>;
+    release(request: SdkLeaseReleaseRequest): Promise<void>;
+    update(request: SdkUpdateRequest): Promise<SdkLeaseEntity | null>;
+    releaseAll(): Promise<number>;
+}

package/dist/src/stores/message-store.d.ts

@@ -0,0 +1,12 @@
+import type { SdkAckMessageRequest, SdkClaimMessageRequest, SdkCreateMessageRequest, SdkMessageEntity, SdkSearchRequest, SdkUpdateRequest } from '../sdk-types.ts';
+import { SqliteStoreBase, type DatabaseRow } from './helpers.ts';
+export declare function messageFromRow(row: DatabaseRow): SdkMessageEntity;
+export declare class MessageStore extends SqliteStoreBase {
+    private usesEnvelopeTable;
+    getById(id: number): Promise<SdkMessageEntity | null>;
+    search(request: SdkSearchRequest): Promise<SdkMessageEntity[]>;
+    claim(request: SdkClaimMessageRequest): Promise<SdkMessageEntity | null>;
+    ack(request: SdkAckMessageRequest): Promise<void>;
+    create(request: SdkCreateMessageRequest): Promise<SdkMessageEntity>;
+    update(request: SdkUpdateRequest): Promise<SdkMessageEntity | null>;
+}

package/dist/src/stores/run-store.d.ts

@@ -0,0 +1,10 @@
+import type { SdkRecordRunRequest, SdkRunEntity, SdkSearchRequest, SdkUpdateRequest } from '../sdk-types.ts';
+import { SqliteStoreBase } from './helpers.ts';
+export declare function runFromRecord(row: Record<string, unknown>): SdkRunEntity;
+export declare class RunStore extends SqliteStoreBase {
+    private usesEnvelopeTable;
+    getByKey(key: string): Promise<SdkRunEntity | null>;
+    search(request: SdkSearchRequest): Promise<SdkRunEntity[]>;
+    record(request: SdkRecordRunRequest): Promise<SdkRunEntity>;
+    update(request: SdkUpdateRequest): Promise<SdkRunEntity>;
+}

package/dist/src/stores/subscription-store.d.ts

@@ -0,0 +1,9 @@
+import type { SdkMutationRequest, SdkSearchRequest, SdkSubscriptionEntity, SdkUpdateRequest } from '../sdk-types.ts';
+import { SqliteStoreBase } from './helpers.ts';
+export declare class SubscriptionStore extends SqliteStoreBase {
+    private usesEnvelopeTable;
+    getByKey(key: string): Promise<SdkSubscriptionEntity | null>;
+    search(request: SdkSearchRequest): Promise<SdkSubscriptionEntity[]>;
+    create(request: SdkMutationRequest): Promise<SdkSubscriptionEntity | null>;
+    update(request: SdkUpdateRequest): Promise<SdkSubscriptionEntity | null>;
+}