@columenlabs/lumen-tasks 0.0.0-stage → 0.1.93

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Columen Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,12 @@
+Lumen
+Copyright (c) 2026 Columen Labs. Licensed under the MIT License (see LICENSE).
+
+Lumen draws price and market charts with TradingView Lightweight Charts™
+(https://github.com/tradingview/lightweight-charts), Copyright (c) 2025
+TradingView, Inc., licensed under the Apache License 2.0. Lumen turns off the
+chart's own logo, so per that library's NOTICE, an app that shows these charts
+should link to https://www.tradingview.com/ somewhere a user can find it (an
+About page or footer is enough).
+
+The components under packages/ui/src/ui are based on shadcn/ui
+(https://ui.shadcn.com), MIT License, Copyright (c) 2023 shadcn.

package/README.md

@@ -1,3 +1,54 @@
-# Temporary Holding Version
+# @columenlabs/lumen-tasks
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Lumen's background jobs, server side: a ledger of the work a person started (a search, a sync, a backfill) with its state, progress and result, cooperative cancel, a reaper that fails anything stuck, and the routes the header Tasks list calls. It pairs with `TasksProvider`, `TasksButton` and `useTaskFor` in `@columenlabs/lumen-ui`, which show a ring while something runs, a dot for ended unseen tasks and a toast with Open when one ends. No dependencies beyond `@columenlabs/lumen-ui-types`: `Request`, `Response` and any SQLite, so it runs in a Worker, a Durable Object, Bun or Node.
+
+- Source: https://github.com/columenlabs/lumen (`packages/tasks`). MIT.
+
+## Install
+
+```bash
+bun add @columenlabs/lumen-tasks @columenlabs/lumen-ui-types
+```
+
+Pin both to the same exact version as the other Lumen packages.
+
+## The ledger
+
+```ts
+import { createTasks, doSql } from '@columenlabs/lumen-tasks';
+
+const tasks = createTasks({
+  db: doSql(ctx.storage.sql),        // or d1Sql(env.DB)
+  onEnd: async (t) => { /* email or push for long ones */ },
+});
+```
+
+Nothing runs in the ledger. The work runs where its data is (a Durable Object's alarm, a queue, a runner elsewhere) and reports:
+
+```ts
+const t = await tasks.start({
+  owner, app: 'jobs', kind: 'search', title: 'Search · Remote roles',
+  link: '/feed', ref: search.id, total: 3, unit: 'sources',
+});
+for (const [i, source] of sources.entries()) {
+  if ((await tasks.progress(t.id, { done: i })).stop) return; // cancelled or reaped
+  await source.run();
+}
+await tasks.finish(t.id, { state: 'done', summary: '14 new jobs' });
+```
+
+- **Cancel is cooperative.** It ends the task at once; the engine's next `progress` answers `stop: true`. Pass `cancellable: false` for work that cannot stop.
+- **Nothing stays running.** A task open past `limitMinutes` (15) is failed on the next read; no cron needed.
+- **Kept 7 days** (`keepDays`), newest first, 100 at most in a list.
+- `byRef(owner, kind, ref)` finds the newest task for one piece of work, so an engine refuses a second run while one is open.
+
+## The routes
+
+```ts
+import { taskRoutes } from '@columenlabs/lumen-tasks';
+
+const routes = taskRoutes({ base: '/api/tasks', tasks: () => tasks, owner: (req) => callerId(req) });
+app.all('/api/tasks/*', (c) => routes(c.req.raw));
+```
+
+`GET /`, `GET /:id`, `POST /seen`, `POST /clear`, `POST /:id/clear`, `POST /:id/cancel`. Writes must be same-origin JSON. `tasks` may return a stub that forwards to a Durable Object holding the ledger (`TasksApi`).

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createTasks, d1Sql, doSql, publicTask, type SqlRunner, type StoredTask, type TaskEnd, type Tasks, type TasksOptions, type TaskStart, } from './store.js';
+export { type TaskRoutesOptions, type TasksApi, taskRoutes } from './routes.js';
+export type { Task, TaskList, TaskState } from '@columenlabs/lumen-ui-types/tasks';

package/dist/index.js

@@ -0,0 +1,5 @@
+// Lumen's background jobs on the server. The header list and toasts are `TasksProvider` and
+// `TasksButton` in `@columenlabs/lumen-ui`; the shapes both share are
+// `@columenlabs/lumen-ui-types/tasks`.
+export { createTasks, d1Sql, doSql, publicTask, } from './store.js';
+export { taskRoutes } from './routes.js';

package/dist/routes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The HTTP routes the header Tasks list calls (`TasksProvider` in `@columenlabs/lumen-ui`), as one
+ * fetch handler on Web `Request`/`Response`, so it mounts in any router:
+ *
+ *   app.all('/api/tasks/*', (c) => tasks(c.req.raw));        // Hono
+ *
+ *   GET  /            the caller's list (last 7 days, newest first)
+ *   GET  /:id         one task
+ *   POST /seen        marks every ended task seen
+ *   POST /clear       drops every ended task;  POST /:id/clear  drops one
+ *   POST /:id/cancel  cancels one
+ *
+ * Every call needs a caller; writes must be same-origin JSON, since a signed-in browser session is
+ * a cookie and a foreign page's form or fetch must not reach the ledger.
+ */
+import type { Task, TaskList } from '@columenlabs/lumen-ui-types/tasks';
+import type { Tasks } from './store.js';
+type Awaitable<T> = T | Promise<T>;
+/** The ledger calls the routes make: the ledger itself, or a stub that forwards to it (a Durable
+ *  Object that holds it). */
+export interface TasksApi {
+    list(owner: string): Awaitable<TaskList>;
+    read(owner: string, id: string): Awaitable<Task | null>;
+    cancel(owner: string, id: string): Awaitable<Task | null>;
+    seen(owner: string): Awaitable<void>;
+    clear(owner: string, id?: string): Awaitable<void>;
+}
+export interface TaskRoutesOptions {
+    /** Where the routes are mounted (`/api/tasks`). */
+    base: string;
+    /** The ledger for this request. */
+    tasks: (req: Request) => Awaitable<TasksApi | Tasks>;
+    /** The verified caller's owner id (the same one the engines `start` with), or null (403). */
+    owner: (req: Request) => Awaitable<string | null>;
+}
+export declare function taskRoutes(opts: TaskRoutesOptions): (req: Request) => Promise<Response>;
+export {};

package/dist/routes.js

@@ -0,0 +1,54 @@
+const HEADERS = { 'content-type': 'application/json', 'cache-control': 'no-store' };
+const json = (body, status = 200) => new Response(JSON.stringify(body), { status, headers: HEADERS });
+const fail = (error, status) => json({ error }, status);
+export function taskRoutes(opts) {
+    const base = opts.base.replace(/\/$/, '');
+    return async (req) => {
+        const url = new URL(req.url);
+        if (!url.pathname.startsWith(base))
+            return fail('not_found', 404);
+        const parts = url.pathname
+            .slice(base.length)
+            .split('/')
+            .filter(Boolean)
+            .map(decodeURIComponent);
+        const owner = await opts.owner(req);
+        if (!owner)
+            return fail('forbidden', 403);
+        if (req.method === 'POST') {
+            if (req.headers.get('origin') !== url.origin)
+                return fail('forbidden_origin', 403);
+            if (!(req.headers.get('content-type') ?? '').toLowerCase().startsWith('application/json'))
+                return fail('json_only', 415);
+        }
+        const tasks = await opts.tasks(req);
+        const [a, b] = parts;
+        if (req.method === 'GET') {
+            if (parts.length === 0)
+                return json(await tasks.list(owner));
+            if (parts.length === 1 && a) {
+                const t = await tasks.read(owner, a);
+                return t ? json({ task: t }) : fail('not_found', 404);
+            }
+        }
+        if (req.method === 'POST') {
+            if (parts.length === 1 && a === 'seen') {
+                await tasks.seen(owner);
+                return json({ ok: true });
+            }
+            if (parts.length === 1 && a === 'clear') {
+                await tasks.clear(owner);
+                return json({ ok: true });
+            }
+            if (parts.length === 2 && a && b === 'clear') {
+                await tasks.clear(owner, a);
+                return json({ ok: true });
+            }
+            if (parts.length === 2 && a && b === 'cancel') {
+                const t = await tasks.cancel(owner, a);
+                return t ? json({ task: t }) : fail('not_found', 404);
+            }
+        }
+        return fail('not_found', 404);
+    };
+}

package/dist/store.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The Tasks ledger: one row a background job a person started, in any SQLite (a Durable Object's
+ * own through `doSql`, or D1 through `d1Sql`). The engine that does the work reports here
+ * (`start`, `progress`, `finish`); the person reads, cancels and clears through `taskRoutes`.
+ *
+ * Nothing runs here: the work runs where its data is (a Durable Object's alarm, a queue, a runner
+ * elsewhere) and only reports. Cancel is cooperative: it ends the task at once, and the engine's
+ * next `progress` answers `stop: true`, so it stops between steps. A task open past its limit is
+ * failed by the reaper, which runs on every read, so no cron is needed and nothing stays running
+ * for good. Ended tasks are kept `keepDays` (7) and then dropped.
+ *
+ * Table `tasks` (plain rows: a title names what ran, never amounts or private values).
+ */
+import type { Task, TaskList } from '@columenlabs/lumen-ui-types/tasks';
+type Row = Record<string, unknown>;
+/** The SQL a ledger needs: the same shape as `lumen-people`'s, so one runner serves both. */
+export interface SqlRunner {
+    all(sql: string, ...args: unknown[]): Promise<Row[]>;
+    run(sql: string, ...args: unknown[]): Promise<void>;
+}
+/** A Durable Object's SQLite (`ctx.storage.sql`). */
+export declare function doSql(sql: {
+    exec(q: string, ...args: unknown[]): {
+        toArray(): unknown[];
+    };
+}): SqlRunner;
+/** A D1 database binding. */
+export declare function d1Sql(db: {
+    prepare(q: string): {
+        bind(...a: unknown[]): {
+            all(): Promise<{
+                results: unknown[];
+            }>;
+            run(): Promise<unknown>;
+        };
+    };
+}): SqlRunner;
+/** What an engine gives when it starts a job. */
+export interface TaskStart {
+    /** Whose task it is (the app's stable id for the person, such as their email). */
+    owner: string;
+    /** The app it runs on; the list names it when tasks come from several. */
+    app: string;
+    /** What kind of work (`search`, `sync`, `backfill`). */
+    kind: string;
+    /** `Search · Remote roles`: what ran, never amounts or private values. */
+    title: string;
+    /** The page with the result, a whole address. */
+    link?: string | null;
+    /** How many steps, in `unit`, when the engine counts. */
+    total?: number | null;
+    unit?: string | null;
+    /** The engine's own id for the work, so a page finds the task its button started. */
+    ref?: string | null;
+    /** Whether Cancel works for it (the engine checks `progress`'s `stop`). Default true. */
+    cancellable?: boolean;
+    /** Open longer than this fails it (default 15). */
+    limitMinutes?: number;
+    /** Starts as running (default) or queued, for work that waits its turn. */
+    state?: 'queued' | 'running';
+}
+/** How a job ended. */
+export interface TaskEnd {
+    state: 'done' | 'failed';
+    /** One line on the result (`14 new jobs`). */
+    summary?: string | null;
+    /** Why it failed. */
+    error?: string | null;
+    /** The result's page, when it is only known at the end. */
+    link?: string | null;
+}
+/** A task as stored: `owner` and the limit stay on the server. */
+export interface StoredTask extends Task {
+    owner: string;
+    limit_minutes: number;
+}
+export interface TasksOptions {
+    db: SqlRunner;
+    /** Days an ended task is kept (default 7). */
+    keepDays?: number;
+    /** Called once when a task ends (done, failed, cancelled or reaped), to notify the person
+     *  (email, push) for long ones. Errors are swallowed: a failed notice never fails the job. */
+    onEnd?: (task: StoredTask) => Promise<void> | void;
+    /** The clock (tests and replays); default `Date.now`. */
+    now?: () => number;
+}
+export interface Tasks {
+    start(t: TaskStart): Promise<StoredTask>;
+    /** Reports progress; `stop` is true once the task is no longer open (cancelled or reaped),
+     *  so the engine stops between steps. */
+    progress(id: string, p: {
+        done?: number | null;
+        total?: number | null;
+        state?: 'running';
+    }): Promise<{
+        stop: boolean;
+    }>;
+    /** Ends an open task; an already ended one (cancelled meanwhile) stays as it is and gives null. */
+    finish(id: string, end: TaskEnd): Promise<StoredTask | null>;
+    get(id: string): Promise<StoredTask | null>;
+    /** The person's newest task for one piece of work (`kind` + `ref`). */
+    byRef(owner: string, kind: string, ref: string): Promise<StoredTask | null>;
+    /** The person's tasks over the kept days, newest first; reaps first. */
+    list(owner: string): Promise<TaskList>;
+    /** The person's task, or null. */
+    read(owner: string, id: string): Promise<Task | null>;
+    cancel(owner: string, id: string): Promise<Task | null>;
+    /** Marks every ended task of the person seen. */
+    seen(owner: string): Promise<void>;
+    /** Drops one ended task, or every ended one; open tasks stay. */
+    clear(owner: string, id?: string): Promise<void>;
+    /** Fails tasks open past their limit and drops old ended ones. */
+    reap(): Promise<void>;
+}
+/** What the person sees: the stored task without the owner and the limit. */
+export declare function publicTask(t: StoredTask): Task;
+export declare function createTasks(opts: TasksOptions): Tasks;
+export {};

package/dist/store.js

@@ -0,0 +1,208 @@
+import { isActive } from '@columenlabs/lumen-ui-types/tasks';
+/** A Durable Object's SQLite (`ctx.storage.sql`). */
+export function doSql(sql) {
+    return {
+        all: async (q, ...a) => sql.exec(q, ...a).toArray(),
+        run: async (q, ...a) => {
+            sql.exec(q, ...a);
+        },
+    };
+}
+/** A D1 database binding. */
+export function d1Sql(db) {
+    return {
+        all: async (q, ...a) => (await db
+            .prepare(q)
+            .bind(...a)
+            .all()).results,
+        run: async (q, ...a) => {
+            await db
+                .prepare(q)
+                .bind(...a)
+                .run();
+        },
+    };
+}
+const DAY_MS = 24 * 60 * 60_000;
+const iso = (v) => (v == null ? null : new Date(Number(v)).toISOString());
+const num = (v) => (v == null ? null : Number(v));
+const str = (v) => (v == null ? null : String(v));
+const STATES = ['queued', 'running', 'done', 'failed', 'cancelled'];
+function toTask(r) {
+    const state = STATES.includes(r.state) ? r.state : 'failed';
+    return {
+        id: String(r.id),
+        owner: String(r.owner),
+        app: String(r.app),
+        kind: String(r.kind),
+        title: String(r.title),
+        link: str(r.link),
+        state,
+        done: num(r.done),
+        total: num(r.total),
+        unit: str(r.unit),
+        summary: str(r.summary),
+        error: str(r.error),
+        ref: str(r.ref),
+        cancellable: Number(r.cancellable) === 1 && isActive({ state }),
+        created_at: iso(r.created_at) ?? new Date(0).toISOString(),
+        started_at: iso(r.started_at),
+        finished_at: iso(r.finished_at),
+        seen_at: iso(r.seen_at),
+        limit_minutes: Number(r.limit_minutes ?? 15),
+    };
+}
+/** What the person sees: the stored task without the owner and the limit. */
+export function publicTask(t) {
+    const { owner: _o, limit_minutes: _l, ...rest } = t;
+    return rest;
+}
+export function createTasks(opts) {
+    const { db } = opts;
+    const now = opts.now ?? Date.now;
+    const keep = (opts.keepDays ?? 7) * DAY_MS;
+    let ready = null;
+    const init = () => {
+        ready ??= (async () => {
+            await db.run(`CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY, owner TEXT NOT NULL, app TEXT NOT NULL, kind TEXT NOT NULL,
+        title TEXT NOT NULL, link TEXT, state TEXT NOT NULL, done REAL, total REAL, unit TEXT,
+        summary TEXT, error TEXT, ref TEXT, cancellable INTEGER NOT NULL DEFAULT 1,
+        limit_minutes INTEGER NOT NULL DEFAULT 15, created_at INTEGER NOT NULL,
+        started_at INTEGER, finished_at INTEGER, seen_at INTEGER)`);
+            await db.run('CREATE INDEX IF NOT EXISTS tasks_owner ON tasks (owner, created_at)');
+            await db.run('CREATE INDEX IF NOT EXISTS tasks_open ON tasks (state)');
+        })().catch((e) => {
+            ready = null;
+            throw e;
+        });
+        return ready;
+    };
+    const one = async (id) => {
+        await init();
+        const [r] = await db.all('SELECT * FROM tasks WHERE id = ?', id);
+        return r ? toTask(r) : null;
+    };
+    const ended = async (t) => {
+        if (!t || !opts.onEnd)
+            return;
+        try {
+            await opts.onEnd(t);
+        }
+        catch {
+            // A notice that fails never fails the job.
+        }
+    };
+    // Ends an open task; gives it when this call ended it (so `onEnd` fires once), else null.
+    const end = async (id, state, set) => {
+        const before = await one(id);
+        if (!before || !isActive(before))
+            return null;
+        const cols = Object.keys(set);
+        await db.run(`UPDATE tasks SET state = ?, finished_at = ?${cols.map((c) => `, ${c} = ?`).join('')}
+       WHERE id = ? AND state IN ('queued', 'running')`, state, now(), ...cols.map((c) => set[c] ?? null), id);
+        return one(id);
+    };
+    const tasks = {
+        async start(t) {
+            await init();
+            const id = crypto.randomUUID();
+            const at = now();
+            const state = t.state ?? 'running';
+            await db.run(`INSERT INTO tasks (id, owner, app, kind, title, link, state, done, total, unit, ref,
+          cancellable, limit_minutes, created_at, started_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, t.owner, t.app, t.kind, t.title, t.link ?? null, state, t.total ? 0 : null, t.total ?? null, t.unit ?? null, t.ref ?? null, t.cancellable === false ? 0 : 1, t.limitMinutes ?? 15, at, state === 'running' ? at : null);
+            return (await one(id));
+        },
+        async progress(id, p) {
+            await init();
+            const sets = [];
+            const args = [];
+            if (p.done !== undefined) {
+                sets.push('done = ?');
+                args.push(p.done);
+            }
+            if (p.total !== undefined) {
+                sets.push('total = ?');
+                args.push(p.total);
+            }
+            if (p.state === 'running') {
+                sets.push("state = 'running', started_at = COALESCE(started_at, ?)");
+                args.push(now());
+            }
+            if (sets.length)
+                await db.run(`UPDATE tasks SET ${sets.join(', ')} WHERE id = ? AND state IN ('queued', 'running')`, ...args, id);
+            const t = await one(id);
+            return { stop: !t || !isActive(t) };
+        },
+        async finish(id, e) {
+            await init();
+            const t = await end(id, e.state, {
+                summary: e.summary ?? null,
+                error: e.state === 'failed' ? (e.error ?? 'Failed') : null,
+                ...(e.link !== undefined ? { link: e.link } : {}),
+            });
+            // A done task's progress reads full.
+            if (t && e.state === 'done' && t.total != null) {
+                await db.run('UPDATE tasks SET done = total WHERE id = ?', id);
+                t.done = t.total;
+            }
+            await ended(t);
+            return t;
+        },
+        get: one,
+        async byRef(owner, kind, ref) {
+            await init();
+            const [r] = await db.all('SELECT * FROM tasks WHERE owner = ? AND kind = ? AND ref = ? ORDER BY created_at DESC LIMIT 1', owner, kind, ref);
+            return r ? toTask(r) : null;
+        },
+        async list(owner) {
+            await tasks.reap();
+            const rows = await db.all('SELECT * FROM tasks WHERE owner = ? AND created_at >= ? ORDER BY created_at DESC LIMIT 100', owner, now() - keep);
+            const list = rows.map(toTask);
+            return {
+                tasks: list.map(publicTask),
+                active: list.filter(isActive).length,
+                unseen: list.filter((t) => t.finished_at && !t.seen_at).length,
+            };
+        },
+        async read(owner, id) {
+            const t = await one(id);
+            return t && t.owner === owner ? publicTask(t) : null;
+        },
+        async cancel(owner, id) {
+            const t = await one(id);
+            if (!t || t.owner !== owner)
+                return null;
+            if (!t.cancellable)
+                return publicTask(t);
+            const done = await end(id, 'cancelled', { error: 'Cancelled' });
+            await ended(done);
+            return publicTask(done ?? (await one(id)));
+        },
+        async seen(owner) {
+            await init();
+            await db.run('UPDATE tasks SET seen_at = ? WHERE owner = ? AND finished_at IS NOT NULL AND seen_at IS NULL', now(), owner);
+        },
+        async clear(owner, id) {
+            await init();
+            if (id)
+                await db.run('DELETE FROM tasks WHERE owner = ? AND id = ? AND finished_at IS NOT NULL', owner, id);
+            else
+                await db.run('DELETE FROM tasks WHERE owner = ? AND finished_at IS NOT NULL', owner);
+        },
+        async reap() {
+            await init();
+            const at = now();
+            const stuck = await db.all("SELECT id, limit_minutes FROM tasks WHERE state IN ('queued', 'running') AND created_at < ? - limit_minutes * 60000", at);
+            for (const r of stuck) {
+                const t = await end(String(r.id), 'failed', {
+                    error: `Stopped after ${Number(r.limit_minutes)} ${Number(r.limit_minutes) === 1 ? 'minute' : 'minutes'}`,
+                });
+                await ended(t);
+            }
+            await db.run('DELETE FROM tasks WHERE finished_at IS NOT NULL AND finished_at < ?', at - keep);
+        },
+    };
+    return tasks;
+}

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@columenlabs/lumen-tasks",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.93",
+  "description": "Lumen's background jobs on the server: a ledger of the work a person started (state, progress, result), cancel, a reaper for stuck jobs and the routes the header Tasks list calls.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./store": {
+      "types": "./dist/store.d.ts",
+      "default": "./dist/store.js"
+    },
+    "./routes": {
+      "types": "./dist/routes.d.ts",
+      "default": "./dist/routes.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "homepage": "https://github.com/columenlabs/lumen",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/columenlabs/lumen.git",
+    "directory": "packages/tasks"
+  },
+  "bugs": "https://github.com/columenlabs/lumen/issues",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@columenlabs/lumen-ui-types": "0.1.93"
+  }
+}