@datalayer/agent-runtimes 1.5.45 → 1.5.46

package/lib/portable/hosts/postgresQueue.js

@@ -0,0 +1,217 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The durable work queue on Postgres: jobs claimed with `FOR UPDATE SKIP
+ * LOCKED`, leased and renewed while worked, retried with backoff, dead after
+ * five attempts, an ingress claim and its job kept in one transaction. Its
+ * tables are `<prefix>_jobs`, `<prefix>_event_claims` and
+ * `<prefix>_job_replays` (`hostSchemaSql`). Moved from the Slack service
+ * (plans/DISCORD.md DC-004).
+ *
+ * @module portable/hosts/postgresQueue
+ */
+import { tablePrefixOf, } from './queue';
+export class PostgresWorkQueue {
+    database;
+    tablePrefix;
+    pollIntervalMs;
+    leaseRenewMs;
+    #handler;
+    #loop;
+    #stopping = false;
+    #jobs;
+    #claims;
+    #replays;
+    constructor(database, 
+    /** The host's table prefix: `slack`, `discord`. */
+    tablePrefix, pollIntervalMs = 250, 
+    /**
+     * How often a job being worked renews its lease (S-207): well within the
+     * five minutes after which `reclaimAbandonedJobs` takes a job back, so
+     * only a worker that died loses its job, not one answering a long turn.
+     */
+    leaseRenewMs = 60_000) {
+        this.database = database;
+        this.tablePrefix = tablePrefix;
+        this.pollIntervalMs = pollIntervalMs;
+        this.leaseRenewMs = leaseRenewMs;
+        const prefix = tablePrefixOf(tablePrefix);
+        this.#jobs = `${prefix}_jobs`;
+        this.#claims = `${prefix}_event_claims`;
+        this.#replays = `${prefix}_job_replays`;
+    }
+    async enqueue(item, idempotencyKey) {
+        if (!idempotencyKey) {
+            await this.database.query(`INSERT INTO ${this.#jobs} (payload) VALUES ($1)`, [item]);
+            return true;
+        }
+        // The idempotency key and its job in one transaction (§7.1, 4).
+        const client = await this.database.connect();
+        try {
+            await client.query('BEGIN');
+            const claimed = await client.query(`INSERT INTO ${this.#claims} (event_id) VALUES ($1) ON CONFLICT DO NOTHING RETURNING event_id`, [`ingress:${idempotencyKey}`]);
+            if (claimed.rowCount === 1)
+                await client.query(`INSERT INTO ${this.#jobs} (payload) VALUES ($1)`, [
+                    item,
+                ]);
+            await client.query('COMMIT');
+            return claimed.rowCount === 1;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async ready() {
+        try {
+            await this.database.query(`SELECT 1 FROM ${this.#jobs} LIMIT 1`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Jobs that failed five times, with their metadata only: what the dead-letter tool lists. */
+    async dead(limit = 50) {
+        const result = await this.database.query(`SELECT id::text, attempts, last_error, created_at,
+              CASE WHEN payload ? 'delivery' THEN 'delivery'
+                   WHEN payload ? 'prompt' THEN 'prompt'
+                   ELSE 'other' END AS kind
+       FROM ${this.#jobs} WHERE state = 'dead' ORDER BY id LIMIT $1`, [limit]);
+        return result.rows.map(row => ({
+            attempts: row.attempts,
+            createdAt: new Date(row.created_at).toISOString(),
+            id: row.id,
+            kind: row.kind ?? 'other',
+            lastError: row.last_error,
+        }));
+    }
+    /**
+     * Put a dead job back to work: once, by id, the replay kept with who asked
+     * in the same transaction (`<prefix>_job_replays`, SLACK S-405), refused or not.
+     */
+    async replay(id, operator) {
+        if (!/^\d+$/.test(id))
+            return false;
+        const client = await this.database.connect();
+        try {
+            await client.query('BEGIN');
+            const result = await client.query(`UPDATE ${this.#jobs} SET state = 'ready', attempts = 0, available_at = now(), last_error = NULL WHERE id = $1 AND state = 'dead'`, [id]);
+            const replayed = result.rowCount === 1;
+            await client.query(`INSERT INTO ${this.#replays} (job_id, operator, replayed) VALUES ($1, $2, $3)`, [id, operator, replayed]);
+            await client.query('COMMIT');
+            return replayed;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    /**
+     * A dead job's payload, and only a dead one's (S-405): a live job, or an id
+     * that is no job, has none to read here.
+     */
+    async payloadOf(id) {
+        if (!/^\d+$/.test(id))
+            return undefined;
+        const result = await this.database.query(`SELECT payload FROM ${this.#jobs} WHERE id = $1 AND state = 'dead'`, [id]);
+        return result.rows[0]?.payload;
+    }
+    start(handler) {
+        if (this.#loop)
+            throw new Error('The PostgreSQL work queue has already started.');
+        this.#handler = handler;
+        this.#stopping = false;
+        this.#loop = this.#run();
+    }
+    async stop() {
+        this.#stopping = true;
+        await this.#loop;
+        this.#loop = undefined;
+        this.#handler = undefined;
+    }
+    async #run() {
+        while (!this.#stopping) {
+            const job = await this.#claim();
+            if (!job) {
+                await delay(this.pollIntervalMs);
+                continue;
+            }
+            const lease = setInterval(() => {
+                void this.database
+                    .query(`UPDATE ${this.#jobs} SET locked_at = now() WHERE id = $1 AND state = 'processing'`, [job.id])
+                    .catch(() => undefined); // the next renewal, or the reclaim, decides
+            }, this.leaseRenewMs);
+            lease.unref?.();
+            try {
+                await this.#handler?.(job.payload);
+                await this.database.query(`DELETE FROM ${this.#jobs} WHERE id = $1`, [
+                    job.id,
+                ]);
+            }
+            catch (error) {
+                await this.#fail(job, error);
+            }
+            finally {
+                clearInterval(lease);
+            }
+        }
+    }
+    async #claim() {
+        const client = await this.database.connect();
+        try {
+            await client.query('BEGIN');
+            await reclaimAbandonedJobs(client, this.#jobs);
+            const selected = await client.query(`SELECT id::text, payload, attempts
+         FROM ${this.#jobs}
+         WHERE state = 'ready' AND available_at <= now()
+         ORDER BY id
+         FOR UPDATE SKIP LOCKED
+         LIMIT 1`);
+            const job = selected.rows[0];
+            if (!job) {
+                await client.query('COMMIT');
+                return undefined;
+            }
+            await client.query(`UPDATE ${this.#jobs}
+         SET state = 'processing', attempts = attempts + 1, locked_at = now()
+         WHERE id = $1`, [job.id]);
+            await client.query('COMMIT');
+            return { ...job, attempts: job.attempts + 1 };
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async #fail(job, error) {
+        const message = error instanceof Error ? error.message : 'Unknown worker failure';
+        if (job.attempts >= 5) {
+            await this.database.query(`UPDATE ${this.#jobs} SET state = 'dead', last_error = $2, locked_at = NULL WHERE id = $1`, [job.id, message.slice(0, 2_000)]);
+            return;
+        }
+        const delaySeconds = Math.min(300, 2 ** job.attempts);
+        await this.database.query(`UPDATE ${this.#jobs}
+       SET state = 'ready', available_at = now() + ($2 * interval '1 second'),
+           last_error = $3, locked_at = NULL
+       WHERE id = $1`, [job.id, delaySeconds, message.slice(0, 2_000)]);
+    }
+}
+async function reclaimAbandonedJobs(client, jobs) {
+    await client.query(`UPDATE ${jobs}
+     SET state = 'ready', available_at = now(), locked_at = NULL,
+         last_error = 'Worker lease expired'
+     WHERE state = 'processing' AND locked_at < now() - interval '5 minutes'`);
+}
+const delay = async (milliseconds) => new Promise(resolve => setTimeout(resolve, milliseconds));

package/lib/portable/hosts/queue.d.ts

@@ -0,0 +1,47 @@
+/**
+ * A host's durable work queue, its in-memory development stand-in, and the
+ * structural Postgres connection every Postgres implementation here takes
+ * (`pg.Pool` and `pg.PoolClient` satisfy it: no `pg` import). Moved from the
+ * Slack service (plans/DISCORD.md DC-004).
+ *
+ * @module portable/hosts/queue
+ */
+/** What a query answers: its rows, and how many it changed. */
+export type QueryAnswer<R> = {
+    rows: R[];
+    rowCount: number | null;
+};
+/** A Postgres connection as the hosts code uses it: `pg.Pool` or `pg.PoolClient`. */
+export interface Queryable {
+    query<R extends {
+        [column: string]: any;
+    } = any>(text: string, values?: any[]): Promise<QueryAnswer<R>>;
+}
+/** A pool of connections, one taken for a transaction: `pg.Pool`. */
+export interface ConnectionPool extends Queryable {
+    connect(): Promise<Queryable & {
+        release(): void;
+    }>;
+}
+/** A table prefix a host's tables carry (`slack`, `discord`): lowercase letters and digits. */
+export declare function tablePrefixOf(prefix: string): string;
+export interface WorkQueue<T> {
+    /**
+     * Persist one job. With an idempotency key (a host event or action id),
+     * the key and the job are kept in one transaction and a second job under
+     * the same key is not enqueued: `false`.
+     */
+    enqueue(item: T, idempotencyKey?: string): Promise<boolean>;
+    /** Whether the queue can take durable work now: what readiness reports. */
+    ready(): Promise<boolean>;
+    start(handler: (item: T) => Promise<void>): void;
+    stop(): Promise<void>;
+}
+/** In-process development queue. A durable adapter is required in production. */
+export declare class MemoryWorkQueue<T> implements WorkQueue<T> {
+    #private;
+    enqueue(item: T, idempotencyKey?: string): Promise<boolean>;
+    ready(): Promise<boolean>;
+    start(handler: (item: T) => Promise<void>): void;
+    stop(): Promise<void>;
+}

package/lib/portable/hosts/queue.js

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/** A table prefix a host's tables carry (`slack`, `discord`): lowercase letters and digits. */
+export function tablePrefixOf(prefix) {
+    if (!/^[a-z][a-z0-9]{1,31}$/.test(prefix)) {
+        throw new Error(`A table prefix is lowercase letters and digits, a letter first: ${prefix}.`);
+    }
+    return prefix;
+}
+/** In-process development queue. A durable adapter is required in production. */
+export class MemoryWorkQueue {
+    #items = [];
+    #keys = new Set();
+    #handler;
+    #running = false;
+    async enqueue(item, idempotencyKey) {
+        if (idempotencyKey) {
+            if (this.#keys.has(idempotencyKey)) {
+                return false;
+            }
+            this.#keys.add(idempotencyKey);
+        }
+        this.#items.push(item);
+        queueMicrotask(() => void this.#drain());
+        return true;
+    }
+    async ready() {
+        return true;
+    }
+    start(handler) {
+        this.#handler = handler;
+        void this.#drain();
+    }
+    async stop() {
+        this.#handler = undefined;
+        while (this.#running) {
+            await new Promise(resolve => setTimeout(resolve, 5));
+        }
+    }
+    async #drain() {
+        if (this.#running || !this.#handler) {
+            return;
+        }
+        this.#running = true;
+        try {
+            while (this.#items.length > 0) {
+                const handler = this.#handler;
+                if (!handler) {
+                    break;
+                }
+                const item = this.#items.shift();
+                if (item !== undefined) {
+                    await handler(item);
+                }
+            }
+        }
+        finally {
+            this.#running = false;
+        }
+    }
+}

package/lib/portable/hosts/quotas.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Quotas before costly work (SLACK §9, S-404; DISCORD DC-402): questions an
+ * hour per person, installation (a Slack workspace, a Discord server),
+ * organization and application, taken atomically before a turn starts at
+ * Datalayer. A refusal says which limit and when it resets. Moved from the
+ * Slack service (plans/DISCORD.md DC-004).
+ *
+ * @module portable/hosts/quotas
+ */
+import { type ConnectionPool } from './queue';
+export type QuotaScope = 'user' | 'installation' | 'organization' | 'application';
+export type QuotaLimits = Readonly<Record<QuotaScope, number>>;
+export declare const DEFAULT_QUOTAS: QuotaLimits;
+export type QuotaEntry = Readonly<{
+    scope: QuotaScope;
+    key: string;
+    limit: number;
+}>;
+export type QuotaTaken = Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    scope: QuotaScope;
+    limit: number;
+    resetsAt: Date;
+}>;
+/** The hour a moment falls in: the period counts are kept by. */
+export declare function windowOf(now: Date): string;
+export declare function resetOf(now: Date): Date;
+/** A person's quota key in an installation: what their usage line reads. */
+export declare function userQuotaKey(installation: string, externalUserId: string): string;
+/**
+ * What each quota counts, for one turn. `keyPrefix` names the installation's
+ * key (`installation:<id>` by default; Slack keeps `workspace:<id>`, the keys
+ * its counts were kept under).
+ */
+export declare function quotaEntries(limits: QuotaLimits, turn: {
+    installation: string;
+    externalUserId: string;
+    applicationId: string;
+    organizationId?: string;
+}, keyPrefix?: string): QuotaEntry[];
+/**
+ * Words for a refusal, said privately. `installation` names the host's
+ * installation as its people say it: "this workspace", "this server".
+ */
+export declare function quotaWords(taken: Extract<QuotaTaken, {
+    ok: false;
+}>, installation: string): string;
+export type QuotaTake = Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    entry: QuotaEntry;
+}>;
+/** Where quota counts are kept. */
+export interface QuotaStore {
+    /**
+     * Take one of each quota for a period, all or none (S-404): refused when
+     * any is spent, naming it.
+     */
+    takeQuota(entries: readonly QuotaEntry[], period: string): Promise<QuotaTake>;
+    /** How much of a quota is used in a period. */
+    quotaUsed(key: string, period: string): Promise<number>;
+}
+/** Counts in memory: development and tests. */
+export declare class MemoryQuotaStore implements QuotaStore {
+    #private;
+    takeQuota(entries: readonly QuotaEntry[], period: string): Promise<QuotaTake>;
+    quotaUsed(key: string, period: string): Promise<number>;
+}
+/** Counts in `<prefix>_usage`, taken in one transaction, rows locked in a stable order. */
+export declare class PostgresQuotaStore implements QuotaStore {
+    #private;
+    readonly database: ConnectionPool;
+    constructor(database: ConnectionPool, options: {
+        tablePrefix: string;
+    });
+    takeQuota(entries: readonly QuotaEntry[], period: string): Promise<QuotaTake>;
+    quotaUsed(key: string, period: string): Promise<number>;
+}

package/lib/portable/hosts/quotas.js

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Quotas before costly work (SLACK §9, S-404; DISCORD DC-402): questions an
+ * hour per person, installation (a Slack workspace, a Discord server),
+ * organization and application, taken atomically before a turn starts at
+ * Datalayer. A refusal says which limit and when it resets. Moved from the
+ * Slack service (plans/DISCORD.md DC-004).
+ *
+ * @module portable/hosts/quotas
+ */
+import { tablePrefixOf } from './queue';
+export const DEFAULT_QUOTAS = {
+    application: 600,
+    installation: 600,
+    organization: 2_000,
+    user: 60,
+};
+/** The hour a moment falls in: the period counts are kept by. */
+export function windowOf(now) {
+    return now.toISOString().slice(0, 13);
+}
+export function resetOf(now) {
+    const next = new Date(now);
+    next.setUTCMinutes(0, 0, 0);
+    next.setUTCHours(next.getUTCHours() + 1);
+    return next;
+}
+/** A person's quota key in an installation: what their usage line reads. */
+export function userQuotaKey(installation, externalUserId) {
+    return `user:${installation}:${externalUserId}`;
+}
+/**
+ * What each quota counts, for one turn. `keyPrefix` names the installation's
+ * key (`installation:<id>` by default; Slack keeps `workspace:<id>`, the keys
+ * its counts were kept under).
+ */
+export function quotaEntries(limits, turn, keyPrefix = 'installation') {
+    return [
+        {
+            key: userQuotaKey(turn.installation, turn.externalUserId),
+            limit: limits.user,
+            scope: 'user',
+        },
+        {
+            key: `${keyPrefix}:${turn.installation}`,
+            limit: limits.installation,
+            scope: 'installation',
+        },
+        ...(turn.organizationId
+            ? [
+                {
+                    key: `organization:${turn.organizationId}`,
+                    limit: limits.organization,
+                    scope: 'organization',
+                },
+            ]
+            : []),
+        {
+            key: `application:${turn.applicationId}`,
+            limit: limits.application,
+            scope: 'application',
+        },
+    ];
+}
+/**
+ * Words for a refusal, said privately. `installation` names the host's
+ * installation as its people say it: "this workspace", "this server".
+ */
+export function quotaWords(taken, installation) {
+    const whose = {
+        application: 'this application',
+        installation,
+        organization: 'your organization',
+        user: 'you',
+    };
+    const at = taken.resetsAt.toISOString().slice(11, 16);
+    return `@Datalayer has answered ${taken.limit} questions this hour for ${whose[taken.scope]}, its limit. Ask again after ${at} UTC.`;
+}
+/** Counts in memory: development and tests. */
+export class MemoryQuotaStore {
+    #usage = new Map();
+    async takeQuota(entries, period) {
+        const spent = entries.find(entry => (this.#usage.get(`${period}:${entry.key}`) ?? 0) >= entry.limit);
+        if (spent) {
+            return { entry: spent, ok: false };
+        }
+        for (const entry of entries) {
+            this.#usage.set(`${period}:${entry.key}`, (this.#usage.get(`${period}:${entry.key}`) ?? 0) + 1);
+        }
+        return { ok: true };
+    }
+    async quotaUsed(key, period) {
+        return this.#usage.get(`${period}:${key}`) ?? 0;
+    }
+}
+/** Counts in `<prefix>_usage`, taken in one transaction, rows locked in a stable order. */
+export class PostgresQuotaStore {
+    database;
+    #usage;
+    constructor(database, options) {
+        this.database = database;
+        this.#usage = `${tablePrefixOf(options.tablePrefix)}_usage`;
+    }
+    async takeQuota(entries, period) {
+        const client = await this.database.connect();
+        try {
+            await client.query('BEGIN');
+            const taken = await this.#take(client, entries, period);
+            await client.query(taken.ok ? 'COMMIT' : 'ROLLBACK');
+            return taken;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async #take(client, entries, period) {
+        // Rows locked in a stable order: two turns never deadlock on them.
+        const sorted = [...entries].sort((a, b) => a.key.localeCompare(b.key));
+        for (const entry of sorted) {
+            await client.query(`INSERT INTO ${this.#usage} (usage_key, usage_window, used) VALUES ($1, $2, 0)
+         ON CONFLICT (usage_key, usage_window) DO NOTHING`, [entry.key, period]);
+        }
+        const keys = sorted.map(entry => entry.key);
+        const used = await client.query(`SELECT usage_key, used FROM ${this.#usage}
+       WHERE usage_window = $1 AND usage_key = ANY($2::text[])
+       ORDER BY usage_key FOR UPDATE`, [period, keys]);
+        const counts = new Map(used.rows.map(row => [row.usage_key, row.used]));
+        const spent = entries.find(entry => (counts.get(entry.key) ?? 0) >= entry.limit);
+        if (spent) {
+            return { entry: spent, ok: false };
+        }
+        await client.query(`UPDATE ${this.#usage} SET used = used + 1
+       WHERE usage_window = $1 AND usage_key = ANY($2::text[])`, [period, keys]);
+        return { ok: true };
+    }
+    async quotaUsed(key, period) {
+        const result = await this.database.query(`SELECT used FROM ${this.#usage} WHERE usage_key = $1 AND usage_window = $2`, [key, period]);
+        return result.rows[0]?.used ?? 0;
+    }
+}

package/lib/portable/hosts/rateLimit.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The clock a host's rate limiter waits on: the system's, or a test's fake.
+ * Each host keeps its own limiter (Slack's method spacing, Discord's
+ * buckets), since what a 429 says differs by host. Moved from the Slack
+ * service (plans/DISCORD.md DC-004).
+ *
+ * @module portable/hosts/rateLimit
+ */
+export interface Clock {
+    now(): number;
+    sleep(milliseconds: number): Promise<void>;
+}
+export declare const systemClock: Clock;

package/lib/portable/hosts/rateLimit.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export const systemClock = {
+    now: () => Date.now(),
+    sleep: milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds)),
+};

package/lib/portable/hosts/resolution.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Which application a host's turn runs (SLACK §8, S-202; DISCORD §8): the
+ * thread's own, else an explicit choice, else the one chosen for the
+ * thread's next session, else the channel's, else the installation's
+ * default; then that application allowed here and in this kind of
+ * conversation. Datalayer's exchange checks the person may open it at every
+ * turn: nothing here authorizes alone. The host says each refusal in its own
+ * words. Moved from the Slack service (plans/DISCORD.md DC-004).
+ *
+ * @module portable/hosts/resolution
+ */
+/** An application the installation allows, as a host keeps it to show and choose from. */
+export type AllowanceView = Readonly<{
+    applicationId: string;
+    name: string;
+    enabled: boolean;
+    /** Whether it answers in channels, or in direct messages only. */
+    channelPolicy: 'channels' | 'direct-only';
+}>;
+/** A channel's own rule: denied, or its default application. */
+export type ChannelRule = Readonly<{
+    state: 'allow' | 'deny';
+    applicationId?: string;
+}>;
+export type ApplicationRefusal = 'channel-denied' | 'no-application' | 'not-allowed' | 'direct-only';
+export type ApplicationResolution<A extends AllowanceView> = Readonly<{
+    ok: true;
+    applicationId: string;
+    allowance?: A;
+}> | Readonly<{
+    ok: false;
+    refusal: ApplicationRefusal;
+    allowance?: A;
+}>;
+/**
+ * The application a turn runs, or why none does. The lookups are read only
+ * when the order reaches them. With no allowance kept, any application is
+ * taken (Datalayer's exchange still decides).
+ */
+export declare function resolveApplication<A extends AllowanceView>(input: {
+    visibility: 'channel' | 'direct';
+    /** The thread's application once it has a session: switching is explicit (S-208). */
+    threadApplication?: string;
+    /** The application chosen with this very prompt. */
+    explicit?: string;
+    /** The application chosen for the thread's next session. */
+    next: () => Promise<string | undefined>;
+    /** The channel's own rule; never read in a direct conversation. */
+    channel: () => Promise<ChannelRule | undefined>;
+    defaultApplication: () => Promise<string | undefined>;
+    allowances: readonly A[];
+}): Promise<ApplicationResolution<A>>;
+/** The applications a person may choose from here: enabled, and answering in this kind of conversation. */
+export declare function usableAllowances<A extends AllowanceView>(allowances: readonly A[], visibility: 'channel' | 'direct'): A[];

package/lib/portable/hosts/resolution.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The application a turn runs, or why none does. The lookups are read only
+ * when the order reaches them. With no allowance kept, any application is
+ * taken (Datalayer's exchange still decides).
+ */
+export async function resolveApplication(input) {
+    let applicationId;
+    if (input.threadApplication) {
+        applicationId = input.threadApplication;
+    }
+    else if (input.explicit) {
+        applicationId = input.explicit;
+    }
+    else {
+        applicationId = await input.next();
+        if (!applicationId) {
+            const channel = input.visibility === 'channel' ? await input.channel() : undefined;
+            if (channel?.state === 'deny') {
+                return { ok: false, refusal: 'channel-denied' };
+            }
+            applicationId =
+                channel?.applicationId ?? (await input.defaultApplication());
+        }
+    }
+    if (!applicationId) {
+        return { ok: false, refusal: 'no-application' };
+    }
+    const allowance = input.allowances.find(one => one.applicationId === applicationId && one.enabled);
+    if (input.allowances.length > 0 && !allowance) {
+        return { ok: false, refusal: 'not-allowed' };
+    }
+    if (allowance?.channelPolicy === 'direct-only' &&
+        input.visibility === 'channel') {
+        return { ok: false, refusal: 'direct-only', allowance };
+    }
+    return { ok: true, applicationId, allowance };
+}
+/** The applications a person may choose from here: enabled, and answering in this kind of conversation. */
+export function usableAllowances(allowances, visibility) {
+    return allowances.filter(one => one.enabled &&
+        (one.channelPolicy === 'channels' || visibility === 'direct'));
+}