lattris 0.1.4 → 0.2.0

package/dist/request/api-fetch.js

@@ -0,0 +1,76 @@
+import { EXIT } from "../store/exit.js";
+import { classifyApiError, edgeExcerpt, parseErrorBody } from "./door.js";
+const HTTP_NO_CONTENT = 204;
+export const apiFetch = async (network, accessToken, url, init = {}, addressKind = 'api') => {
+    const { retryAnonymousOn401 = false, ...requestInit } = init;
+    const request = (token) => {
+        const headers = { ...requestInit.headers };
+        if (token !== undefined)
+            headers.Authorization = `Bearer ${token}`;
+        else if (retryAnonymousOn401)
+            delete headers.Authorization;
+        return network(url, { ...requestInit, headers });
+    };
+    let res = await request(accessToken);
+    const isRead = requestInit.method === undefined || requestInit.method.toUpperCase() === 'GET';
+    if (retryAnonymousOn401 && isRead && accessToken !== undefined && res.status === 401) {
+        await res.body?.cancel().catch(() => { });
+        res = await request(undefined);
+    }
+    if (!res.ok) {
+        const bytes = new Uint8Array(await res.arrayBuffer().catch(() => new ArrayBuffer(0)));
+        const rawText = new TextDecoder().decode(bytes);
+        const excerpt = edgeExcerpt(res.status, { contentType: res.headers.get('content-type'), via: res.headers.get('via') }, bytes);
+        if (excerpt !== null) {
+            return {
+                ok: false,
+                body: {},
+                exit: EXIT.GENERIC,
+                answer: { kind: 'edge', excerpt },
+                status: res.status,
+                rawText
+            };
+        }
+        const body = parseErrorBody(rawText);
+        const { message, next, exit } = classifyApiError(res.status, body);
+        return {
+            ok: false,
+            body,
+            exit,
+            answer: { kind: 'door', message, next },
+            status: res.status,
+            rawText
+        };
+    }
+    if (res.status === HTTP_NO_CONTENT) {
+        return { ok: true, data: undefined, rawText: '', status: res.status };
+    }
+    let rawText;
+    try {
+        rawText = await res.text();
+    }
+    catch (e) {
+        throw new TypeError('fetch failed', { cause: e });
+    }
+    let data;
+    try {
+        data = JSON.parse(rawText);
+    }
+    catch {
+        return {
+            ok: false,
+            body: {},
+            exit: EXIT.GENERIC,
+            answer: { kind: 'page', address: addressKind },
+            status: res.status,
+            rawText
+        };
+    }
+    return { ok: true, data, rawText, status: res.status };
+};
+export const refusalOf = (failed, message = '') => ({
+    message,
+    exit: failed.exit,
+    answer: failed.answer
+});
+//# sourceMappingURL=api-fetch.js.map

package/dist/request/callback.js

@@ -0,0 +1,86 @@
+import { createServer } from 'node:http';
+export const htmlEscape = (s) => s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+export class AuthorizationError extends Error {
+    error;
+    constructor(error) {
+        super(`authorization error: ${error}`);
+        this.error = error;
+    }
+}
+export const decideCallback = (params, expectedState) => {
+    const state = params.get('state');
+    if (!state || state !== expectedState)
+        return { kind: 'state-mismatch' };
+    const error = params.get('error');
+    if (error)
+        return { kind: 'error', error };
+    const code = params.get('code');
+    if (!code)
+        return { kind: 'missing-code' };
+    return { kind: 'success', code };
+};
+const callbackHtml = (ok, message) => `<!doctype html><meta charset="utf-8"><title>lattris</title>` +
+    `<body style="font:16px system-ui;padding:3rem;text-align:center">` +
+    `<h1>${ok ? '✓ Signed in' : '✗ Sign-in failed'}</h1>` +
+    `<p>${htmlEscape(message)}</p>` +
+    `<p style="color:#888">You can close this tab and return to the terminal.</p>`;
+export const waitForCode = (port, expectedState, timeoutMs = 300_000, handle) => new Promise((resolve, reject) => {
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? '/', `http://127.0.0.1:${port}`);
+        if (url.pathname !== '/callback') {
+            res.writeHead(404).end('Not found');
+            return;
+        }
+        const decision = decideCallback(url.searchParams, expectedState);
+        const corsHeaders = (verdict) => ({
+            'Content-Type': 'text/html',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Expose-Headers': 'X-Lattris-Login',
+            'X-Lattris-Login': verdict
+        });
+        if (decision.kind === 'state-mismatch') {
+            res.writeHead(400, corsHeaders('refused'));
+            res.end(callbackHtml(false, 'Invalid or missing state; ignoring this callback.'));
+            return;
+        }
+        const settle = (status, ok, message) => {
+            res.writeHead(status, corsHeaders(ok ? 'ok' : 'refused'));
+            res.end(callbackHtml(ok, message));
+            shutdown();
+        };
+        if (decision.kind === 'success') {
+            settle(200, true, 'Your terminal now holds your Lattris session.');
+            resolve(decision.code);
+            return;
+        }
+        if (decision.kind === 'error') {
+            settle(400, false, `Authorization server returned: ${htmlEscape(decision.error)}`);
+            reject(new AuthorizationError(decision.error));
+            return;
+        }
+        settle(400, false, 'Missing authorization code.');
+        reject(new Error('missing authorization code'));
+    });
+    const shutdown = () => {
+        server.close();
+        server.closeAllConnections();
+        server.unref();
+    };
+    server.on('error', reject);
+    server.listen(port, '127.0.0.1');
+    if (handle)
+        handle.close = shutdown;
+    setTimeout(() => {
+        shutdown();
+        reject(new Error('timed out waiting for the sign-in redirect'));
+    }, timeoutMs).unref();
+});
+export const openBrowser = (machine, url) => {
+    const [cmd, args] = machine.platform === 'darwin'
+        ? ['open', [url]]
+        : machine.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '', url]]
+            : ['xdg-open', [url]];
+    machine.detach(cmd, args);
+};
+//# sourceMappingURL=callback.js.map

package/dist/request/door.js

@@ -0,0 +1,74 @@
+import { EXIT } from "../store/exit.js";
+export const parseErrorBody = (text) => {
+    try {
+        const b = JSON.parse(text);
+        return b && typeof b === 'object' ? b : {};
+    }
+    catch {
+        return {};
+    }
+};
+export const classifyApiError = (status, body) => {
+    if (body.next?.action) {
+        return { message: body.message ?? 'Action required.', next: body.next, exit: EXIT.DOOR };
+    }
+    if (status === 401) {
+        return {
+            message: body.message ?? 'Session invalid or expired.',
+            next: { action: 'login' },
+            exit: EXIT.NOAUTH
+        };
+    }
+    if (status === 403) {
+        return {
+            message: body.message ?? 'Your session lacks a required scope.',
+            next: { action: 'login' },
+            exit: EXIT.NOAUTH
+        };
+    }
+    return {
+        message: body.message ?? `Unexpected response from lattris-api: ${status}`,
+        exit: EXIT.GENERIC
+    };
+};
+const EDGE_REFUSAL_EXCERPT_BYTES = 200;
+export const trimCutUtf8 = (bytes) => {
+    let i = bytes.length - 1;
+    let back = 0;
+    while (i >= 0 && back < 3 && (bytes[i] & 0xc0) === 0x80) {
+        i--;
+        back++;
+    }
+    if (i < 0)
+        return bytes;
+    const lead = bytes[i];
+    const need = lead >= 0xf0 ? 4 : lead >= 0xe0 ? 3 : lead >= 0xc0 ? 2 : 1;
+    const have = bytes.length - i;
+    return have < need ? bytes.subarray(0, i) : bytes;
+};
+const looksLikeHouseError = (text) => {
+    try {
+        const b = JSON.parse(text);
+        return (b !== null &&
+            typeof b === 'object' &&
+            (typeof b.code === 'string' || typeof b.message === 'string'));
+    }
+    catch {
+        return false;
+    }
+};
+export const edgeExcerpt = (status, headers, bytes) => {
+    if (status !== 403)
+        return null;
+    const text = new TextDecoder().decode(bytes);
+    if (looksLikeHouseError(text))
+        return null;
+    const contentType = (headers.contentType ?? '').toLowerCase();
+    const via = (headers.via ?? '').toLowerCase();
+    const isHtml = contentType.includes('text/html') || /^\s*<(!doctype|html)/i.test(text);
+    if (!isHtml && !via.includes('1.1 google'))
+        return null;
+    const prefix = trimCutUtf8(bytes.subarray(0, EDGE_REFUSAL_EXCERPT_BYTES));
+    return new TextDecoder().decode(prefix);
+};
+//# sourceMappingURL=door.js.map

package/dist/request/flags.js

@@ -0,0 +1,38 @@
+export const HELP_TOKENS = new Set(['--help', '-h', 'help']);
+export const parseArgs = (flagNames, args, ids = []) => {
+    const flags = {};
+    const positionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const eq = arg.indexOf('=');
+        const name = eq === -1 ? arg : arg.slice(0, eq);
+        const key = flagNames[name];
+        if (!key)
+            return { flags, positionals, unknown: name };
+        if (eq !== -1) {
+            flags[key] = arg.slice(eq + 1);
+            continue;
+        }
+        const value = args[i + 1];
+        if (value === undefined || value.startsWith('--')) {
+            return { flags, positionals, unknown: name };
+        }
+        flags[key] = value;
+        i++;
+    }
+    const notAnId = ids
+        .map((k) => positionals[k])
+        .find((v) => v === '.' || v === '..' || v?.includes('/'));
+    return notAnId === undefined
+        ? { flags, positionals }
+        : {
+            flags,
+            positionals,
+            notAnId: `Not an id: ${notAnId} — an id is never . or .. and never holds a /.\n`
+        };
+};
+//# sourceMappingURL=flags.js.map

package/dist/request/io.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=io.js.map

package/dist/request/paste-and-device.js

@@ -0,0 +1,99 @@
+import { createInterface } from 'node:readline';
+export const parsePastedAuth = (line, expectedState) => {
+    const params = new URLSearchParams(line.trim().replace(/^\?/, ''));
+    const code = params.get('code');
+    const state = params.get('state');
+    if (!code || !state)
+        return { kind: 'malformed' };
+    if (state !== expectedState)
+        return { kind: 'mismatch' };
+    return { kind: 'code', code };
+};
+export const waitForPastedCode = (expectedState, input, stderr) => {
+    const rl = createInterface({ input });
+    const code = new Promise((resolve) => {
+        rl.on('line', (line) => {
+            if (line.trim() === '')
+                return;
+            const verdict = parsePastedAuth(line, expectedState);
+            if (verdict.kind === 'code') {
+                rl.close();
+                resolve(verdict.code);
+                return;
+            }
+            stderr.write(verdict.kind === 'mismatch'
+                ? 'That code is from a different sign-in attempt — copy it again from the current browser page.\n'
+                : 'That doesn’t look like the code — copy the whole box from the browser page.\n');
+        });
+    });
+    return {
+        code,
+        close: () => {
+            rl.close();
+            input.unref?.();
+        }
+    };
+};
+export const deviceAuthBody = (cfg) => ({
+    client_id: cfg.clientId,
+    scope: cfg.scopes,
+    audience: cfg.audience
+});
+export const requestDeviceAuth = async (network, cfg) => {
+    const res = await network(`${cfg.issuer}/oauth2/device/auth`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams(deviceAuthBody(cfg)).toString()
+    });
+    if (!res.ok) {
+        const detail = await res.text().catch(() => '');
+        throw new Error(`device authorization endpoint ${res.status}: ${detail.slice(0, 300)}`);
+    }
+    return (await res.json());
+};
+const DEVICE_EXPIRED_MESSAGE = 'The sign-in code expired — run lattris login --device again.';
+const deviceTokenAttempt = async (network, cfg, deviceCode) => {
+    const res = await network(`${cfg.issuer}/oauth2/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+            device_code: deviceCode,
+            client_id: cfg.clientId
+        }).toString()
+    });
+    const body = (await res.json().catch(() => ({})));
+    if (res.ok)
+        return { kind: 'token', token: body };
+    switch (body.error) {
+        case 'authorization_pending':
+            return { kind: 'pending' };
+        case 'slow_down':
+            return { kind: 'slow_down' };
+        case 'expired_token':
+            return { kind: 'fail', message: DEVICE_EXPIRED_MESSAGE };
+        case 'access_denied':
+            return { kind: 'fail', message: 'Sign-in was denied.' };
+        default:
+            return {
+                kind: 'fail',
+                message: `token endpoint ${res.status}: ${String(body.error_description ?? body.error ?? '').slice(0, 200)}`
+            };
+    }
+};
+export const pollDeviceToken = async (io, cfg, auth, sleepFn = (ms) => new Promise((r) => setTimeout(r, ms))) => {
+    let interval = (auth.interval ?? 5) * 1000;
+    const deadline = io.now() + auth.expires_in * 1000;
+    while (io.now() < deadline) {
+        const verdict = await deviceTokenAttempt(io.network, cfg, auth.device_code);
+        if (verdict.kind === 'token')
+            return verdict.token;
+        if (verdict.kind === 'fail')
+            throw new Error(verdict.message);
+        if (verdict.kind === 'slow_down')
+            interval += 5000;
+        await sleepFn(interval);
+    }
+    throw new Error(DEVICE_EXPIRED_MESSAGE);
+};
+//# sourceMappingURL=paste-and-device.js.map

package/dist/request/stdin.js

@@ -0,0 +1,22 @@
+import { createInterface } from 'node:readline';
+export const readAll = async (input) => {
+    const chunks = [];
+    for await (const chunk of input)
+        chunks.push(chunk);
+    const text = Buffer.concat(chunks).toString('utf8');
+    return text.endsWith('\n') ? text.slice(0, -1) : text;
+};
+export const ask = (input, output, question) => new Promise((resolve) => {
+    const rl = createInterface({ input, output });
+    let answered = false;
+    rl.once('close', () => {
+        if (!answered)
+            resolve(null);
+    });
+    rl.question(question, (answer) => {
+        answered = true;
+        rl.close();
+        resolve(answer);
+    });
+});
+//# sourceMappingURL=stdin.js.map

package/dist/request/token.js

@@ -0,0 +1,66 @@
+export const emailFromIdToken = (idToken) => {
+    try {
+        const payload = JSON.parse(Buffer.from(idToken.split('.')[1] ?? '', 'base64url').toString());
+        return typeof payload.email === 'string' && payload.email !== '' ? payload.email : null;
+    }
+    catch {
+        return null;
+    }
+};
+export const loginIdentityGate = (homeDir, tokenEmail) => {
+    const dirName = homeDir.split('/').filter(Boolean).at(-1) ?? '';
+    const homeEmail = dirName.includes('@') ? dirName : null;
+    if (!homeEmail)
+        return { save: true };
+    if (!tokenEmail) {
+        return {
+            save: false,
+            message: `Refusing to save: this directory is keyed to ${homeEmail}, but the sign-in ` +
+                `returned no email evidence. Nothing was written — retry the login, or use a ` +
+                `non-email --as home.\n`
+        };
+    }
+    if (homeEmail.toLowerCase() !== tokenEmail.toLowerCase()) {
+        return {
+            save: false,
+            message: `Refusing to save: this directory belongs to ${homeEmail}, but you signed in as ` +
+                `${tokenEmail}. Nothing was written — log in again as ${homeEmail}, ` +
+                `or point --as at ${tokenEmail} instead (\`lattris login\`).\n`
+        };
+    }
+    return { save: true };
+};
+export const toSession = (t, now) => ({
+    accessToken: t.access_token,
+    refreshToken: t.refresh_token,
+    tokenType: t.token_type || 'bearer',
+    expiresAt: Math.floor(now / 1000) + (t.expires_in ?? 0)
+});
+export const postToken = async (network, cfg, body, signal) => {
+    const res = await network(`${cfg.issuer}/oauth2/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams(body).toString(),
+        ...(signal ? { signal } : {})
+    });
+    if (!res.ok) {
+        const detail = await res.text().catch(() => '');
+        throw new Error(`token endpoint ${res.status}: ${detail.slice(0, 300)}`);
+    }
+    return (await res.json());
+};
+export const refreshBody = (cfg, refreshToken) => ({
+    grant_type: 'refresh_token',
+    refresh_token: refreshToken,
+    client_id: cfg.clientId,
+    scope: cfg.scopes
+});
+export const authCodeExchangeBody = (cfg, code, codeVerifier, redirectUri) => ({
+    grant_type: 'authorization_code',
+    code,
+    redirect_uri: redirectUri,
+    client_id: cfg.clientId,
+    code_verifier: codeVerifier
+});
+export const hostedRedirectUri = (cfg) => `${cfg.webUrl}/cli/auth`;
+//# sourceMappingURL=token.js.map

package/dist/request/upload.js

@@ -0,0 +1,6 @@
+export const putToSignedUploadUrl = (network, signedUploadUrl, contentType, bytes) => network(signedUploadUrl, {
+    method: 'PUT',
+    headers: { 'Content-Type': contentType },
+    body: bytes
+});
+//# sourceMappingURL=upload.js.map

package/dist/request/version-check.js

@@ -0,0 +1,79 @@
+import { join } from 'node:path';
+import { readJsonObject } from "../store/json-file.js";
+const VERSION_CHECK_URL = 'https://registry.npmjs.org/lattris/latest';
+const VERSION_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+const VERSION_CHECK_TIMEOUT_MS = 1500;
+const parseVersion = (version) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+    if (!match)
+        return undefined;
+    return {
+        core: [BigInt(match[1]), BigInt(match[2]), BigInt(match[3])],
+        prerelease: match[4] === undefined ? null : match[4].split('.')
+    };
+};
+const compareVersions = (left, right) => {
+    const a = parseVersion(left);
+    const b = parseVersion(right);
+    if (!a || !b)
+        return undefined;
+    for (let i = 0; i < a.core.length; i++) {
+        if (a.core[i] < b.core[i])
+            return -1;
+        if (a.core[i] > b.core[i])
+            return 1;
+    }
+    if (a.prerelease === null && b.prerelease === null)
+        return 0;
+    if (a.prerelease === null)
+        return 1;
+    if (b.prerelease === null)
+        return -1;
+    const length = Math.max(a.prerelease.length, b.prerelease.length);
+    for (let i = 0; i < length; i++) {
+        const av = a.prerelease[i];
+        const bv = b.prerelease[i];
+        if (av === undefined)
+            return -1;
+        if (bv === undefined)
+            return 1;
+        if (av === bv)
+            continue;
+        const aNumber = /^\d+$/.test(av);
+        const bNumber = /^\d+$/.test(bv);
+        if (aNumber && bNumber)
+            return BigInt(av) < BigInt(bv) ? -1 : 1;
+        if (aNumber !== bNumber)
+            return aNumber ? -1 : 1;
+        return av < bv ? -1 : 1;
+    }
+    return 0;
+};
+export const checkForNewVersion = async (io, { currentVersion, stateDir, now }) => {
+    try {
+        const cachePath = join(stateDir, 'version-check.json');
+        const cache = readJsonObject(io.files, cachePath);
+        if (typeof cache?.checkedAt === 'number' && now - cache.checkedAt <= VERSION_CHECK_TTL_MS) {
+            return;
+        }
+        const response = await io.network(VERSION_CHECK_URL, {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(VERSION_CHECK_TIMEOUT_MS)
+        });
+        if (!response.ok)
+            return;
+        const body = (await response.json());
+        if (typeof body.version !== 'string' || parseVersion(body.version) === undefined)
+            return;
+        try {
+            io.files.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+            io.files.writeFileSync(cachePath, `${JSON.stringify({ checkedAt: now, latestVersion: body.version })}\n`, { mode: 0o600 });
+        }
+        catch { }
+        if (compareVersions(currentVersion, body.version) === -1) {
+            io.stderr.write(`lattris ${currentVersion} → ${body.version} available: npm update -g lattris\n`);
+        }
+    }
+    catch { }
+};
+//# sourceMappingURL=version-check.js.map

package/dist/store/chains.js

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+import { safeFileName, sessionDir } from "./session-home.js";
+const receiptsPath = (store, conversationId) => {
+    const name = conversationId === null ? undefined : safeFileName(conversationId);
+    return name === undefined ? undefined : join(sessionDir(store), 'chains', `${name}.json`);
+};
+export const loadReceipts = (store, conversationId) => {
+    const path = receiptsPath(store, conversationId);
+    if (path === undefined)
+        return { epochs: {} };
+    try {
+        return JSON.parse(store.files.readFileSync(path, 'utf8'));
+    }
+    catch {
+        return { epochs: {} };
+    }
+};
+export const saveReceipts = (store, conversationId, receipts) => {
+    const path = receiptsPath(store, conversationId);
+    if (path === undefined)
+        return;
+    store.files.mkdirSync(join(sessionDir(store), 'chains'), { recursive: true, mode: 0o700 });
+    store.files.writeFileSync(path, JSON.stringify(receipts, null, 2), { mode: 0o600 });
+};
+//# sourceMappingURL=chains.js.map

package/dist/store/drafts.js

@@ -0,0 +1,48 @@
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+import { safeFileName, sessionDir } from "./session-home.js";
+const draftsDir = (store) => join(sessionDir(store), 'drafts');
+const draftStamp = (store) => new Date(store.now()).toISOString().replace(/[:.]/g, '-');
+const saveDraft = (store, stem, extension, contents) => {
+    const dir = draftsDir(store);
+    const name = safeFileName(stem);
+    if (name === undefined)
+        throw new Error(`could not keep a draft under ${dir}`);
+    const { chmodSync, mkdirSync, writeFileSync } = store.files;
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+        const file = join(dir, `${name}-${draftStamp(store)}-${randomBytes(4).toString('hex')}.${extension}`);
+        try {
+            writeFileSync(file, contents, { mode: 0o600, flag: 'wx' });
+            chmodSync(file, 0o600);
+            return file;
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+        }
+    }
+    throw new Error(`could not keep a draft under ${dir}`);
+};
+export const saveRequestDraft = (store, kind, draft) => saveDraft(store, kind, 'json', `${JSON.stringify(draft, null, 2)}\n`);
+export const saveEditDraft = (store, blockRef, draft) => {
+    const wordsPath = draft.fields.content !== undefined
+        ? saveDraft(store, blockRef, 'md', `${draft.fields.content}\n`)
+        : undefined;
+    const draftPath = saveDraft(store, blockRef, 'json', `${JSON.stringify({ ...draft, wordsFile: wordsPath }, null, 2)}\n`);
+    return { draftPath, wordsPath };
+};
+export const alreadySaved = (sent, current) => {
+    if (sent.content !== undefined && sent.content !== current.content)
+        return false;
+    if (sent.title !== undefined && sent.title !== (current.title ?? undefined))
+        return false;
+    if (sent.aiSummary !== undefined && sent.aiSummary !== (current.aiSummary ?? undefined))
+        return false;
+    if (sent.intent !== undefined && (sent.intent ?? null) !== (current.intent ?? null))
+        return false;
+    if (sent.contributor !== undefined && sent.contributor !== (current.contributor?.id ?? null))
+        return false;
+    return true;
+};
+//# sourceMappingURL=drafts.js.map