@coffer-org/plugin-media 1.2.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@coffer-org/sdk/plugin").PluginManifest;
+export default _default;

package/dist/index.js

@@ -0,0 +1,28 @@
+import { defineVault } from '@coffer-org/sdk/vault';
+import { definePlugin } from '@coffer-org/sdk/plugin';
+import { field } from '@coffer-org/sdk/fields';
+import { defineSettings } from '@coffer-org/sdk/settings';
+import title from "./title/index.js";
+export default definePlugin({
+    id: 'media',
+    version: '1.0.0',
+    dependsOn: [],
+    vaults: [
+        {
+            meta: defineVault({ id: 'media', label: 'media.vault.label', icon: 'lucide:clapperboard' }),
+            modules: [title],
+        },
+    ],
+    settings: defineSettings({
+        label: 'media.settings.label',
+        fields: [
+            field.password({ key: 'tmdb_key', label: 'media.settings.tmdb_key', required: true }),
+            field.password({ key: 'omdb_key', label: 'media.settings.omdb_key' }),
+            field.string({ key: 'jellyfin_url', label: 'media.settings.jellyfin_url' }),
+            field.password({ key: 'jellyfin_token', label: 'media.settings.jellyfin_token' }),
+            field.string({ key: 'jellyfin_user_id', label: 'media.settings.jellyfin_user_id' }),
+            field.button({ label: 'media.settings.test_button', value: 'media.testJellyfin', icon: 'lucide:wifi' }),
+            field.button({ label: 'media.settings.sync_button', value: 'media.syncJellyfin', icon: 'lucide:refresh-cw' }),
+        ],
+    }),
+});

package/dist/runtime/files.d.ts

@@ -0,0 +1,5 @@
+export declare function downloadImage(url: string, headers?: Record<string, string>, fetchFn?: typeof fetch): Promise<{
+    name: string;
+    mime?: string;
+    size?: number;
+} | undefined>;

package/dist/runtime/files.js

@@ -0,0 +1,22 @@
+import { writeFile } from 'node:fs/promises';
+import { extname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { uploadsDir } from '@coffer-org/server/uploads';
+export async function downloadImage(url, headers, fetchFn = fetch) {
+    try {
+        const resp = await fetchFn(url, headers ? { headers } : undefined);
+        if (!resp.ok)
+            return undefined;
+        const buf = Buffer.from(await resp.arrayBuffer());
+        if (buf.length === 0)
+            return undefined;
+        const mime = resp.headers.get('content-type') ?? undefined;
+        const ext = extname(new URL(url).pathname) || (mime?.includes('png') ? '.png' : '.jpg');
+        const name = `${randomUUID()}${ext}`;
+        await writeFile(join(uploadsDir(), name), buf);
+        return { name, mime, size: buf.length };
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,6 @@
+import type { PluginHooks } from '@coffer-org/server/plugin-hooks';
+export { runJellyfinSync } from './sync.ts';
+export { testConnection } from './jellyfin.ts';
+export declare function addTitle(query?: string, tmdbId?: string, kind?: 'movie' | 'series', source?: string): Promise<Record<string, unknown>>;
+export declare function startSync(): Promise<void>;
+export declare const serverHooks: PluginHooks;

package/dist/runtime/index.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { getPluginSettings } from '@coffer-org/server/plugin-runtime';
+import { localPost } from '@coffer-org/server/local-api';
+import { runJellyfinSync } from "./sync.js";
+import { searchTitle, getDetails } from "./tmdb.js";
+import { getRating } from "./omdb.js";
+import { downloadImage } from "./files.js";
+export { runJellyfinSync } from "./sync.js";
+export { testConnection } from "./jellyfin.js";
+export async function addTitle(query, tmdbId, kind, source = 'agent') {
+    const s = await getPluginSettings('media');
+    const tmdbKey = s['tmdb_key'];
+    const omdbKey = s['omdb_key'];
+    if (!tmdbKey)
+        throw new Error('TMDB API key not configured. Save it in media settings first.');
+    let id = tmdbId;
+    let resolvedKind = kind;
+    if (!id) {
+        if (!query)
+            throw new Error('Provide a query or a tmdb_id.');
+        const hits = await searchTitle(query, tmdbKey, kind);
+        const first = hits[0];
+        if (!first)
+            throw new Error(`No TMDB result for "${query}".`);
+        id = first.tmdb_id;
+        resolvedKind = first.kind;
+    }
+    const d = await getDetails(id, resolvedKind ?? 'movie', tmdbKey);
+    const imdb_rating = d.imdb_id ? await getRating(d.imdb_id, omdbKey) : null;
+    const poster = d.poster ? await downloadImage(d.poster) : undefined;
+    return localPost('media', 'title', {
+        name: d.name,
+        kind: d.kind,
+        poster,
+        year: d.year ?? undefined,
+        overview: d.overview || undefined,
+        genres: d.genres,
+        runtime: d.runtime ?? undefined,
+        tmdb_id: d.tmdb_id,
+        imdb_id: d.imdb_id ?? undefined,
+        tmdb_rating: d.tmdb_rating ?? undefined,
+        imdb_rating: imdb_rating ?? undefined,
+        seasons: d.seasons ?? undefined,
+        episodes: d.episodes ?? undefined,
+        link: d.link ?? undefined,
+        status: 'want',
+        source,
+        in_library: false,
+    });
+}
+export async function startSync() {
+    const r = await runJellyfinSync();
+    console.log(`[media] jellyfin sync: ${r.created} created, ${r.updated} updated`);
+}
+export const serverHooks = {
+    init: () => {
+        void startSync().catch((e) => console.warn(`[media] sync failed to start: ${e.message}`));
+    },
+    agent: {
+        instructions: 'Vault media — movies/series watchlist (title module). kind=movie/series. ' +
+            'status: want=added to the list, not in Jellyfin yet; unwatched=in Jellyfin, not watched; watching; watched; dropped. ' +
+            'in_library, jellyfin_id and source are mirrored from Jellyfin — do not edit manually when source=jellyfin. ' +
+            'To add a movie by name — search_titles (review candidates) then add_title.',
+        tools: [
+            {
+                name: 'search_titles',
+                description: 'Search TMDB for movies/series by name. Returns candidates (does not create a record).',
+                inputSchema: { query: z.string(), kind: z.enum(['movie', 'series']).optional() },
+                handler: async (args) => {
+                    const s = await getPluginSettings('media');
+                    const key = s['tmdb_key'];
+                    if (!key)
+                        throw new Error('TMDB API key not configured.');
+                    return searchTitle(args['query'], key, args['kind']);
+                },
+            },
+            {
+                name: 'add_title',
+                description: 'Creates a media__title record from TMDB by tmdb_id or by name (takes the first result).',
+                inputSchema: {
+                    query: z.string().optional(),
+                    tmdb_id: z.string().optional(),
+                    kind: z.enum(['movie', 'series']).optional(),
+                },
+                handler: (args) => addTitle(args['query'], args['tmdb_id'], args['kind']),
+            },
+        ],
+    },
+};

package/dist/runtime/jellyfin.d.ts

@@ -0,0 +1,29 @@
+export interface JfItem {
+    jellyfin_id: string;
+    name: string;
+    kind: 'movie' | 'series';
+    tmdb_id: string | null;
+    imdb_id: string | null;
+    played: boolean;
+    position_ticks: number;
+    overview: string | null;
+    genres: string[];
+    year: number | null;
+    runtime: number | null;
+    rating: number | null;
+    seasons: number | null;
+    has_image: boolean;
+}
+export interface JfCreds {
+    url: string;
+    token: string;
+    userId: string;
+}
+export declare function normalizeItems(raw: unknown): JfItem[];
+export declare function itemLink(creds: Pick<JfCreds, 'url'>, jellyfinId: string): string;
+export declare function imageUrl(creds: Pick<JfCreds, 'url'>, jellyfinId: string): string;
+export declare function fetchLibrary(creds: JfCreds, fetchFn?: typeof fetch): Promise<JfItem[]>;
+export declare function testConnection(url: string, token: string, fetchFn?: typeof fetch): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

package/dist/runtime/jellyfin.js

@@ -0,0 +1,62 @@
+const str = (v) => (typeof v === 'string' && v ? v : null);
+const num = (v) => (typeof v === 'number' ? v : null);
+export function normalizeItems(raw) {
+    const items = raw?.['Items'] ?? [];
+    const out = [];
+    for (const it of items) {
+        const id = it['Id'];
+        const type = it['Type'];
+        if (typeof id !== 'string')
+            continue;
+        const kind = type === 'Movie' ? 'movie' : type === 'Series' ? 'series' : null;
+        if (!kind)
+            continue;
+        const pids = it['ProviderIds'] ?? {};
+        const ud = it['UserData'] ?? {};
+        const ticks = num(it['RunTimeTicks']);
+        const tags = it['ImageTags'] ?? {};
+        out.push({
+            jellyfin_id: id,
+            name: String(it['Name'] ?? ''),
+            kind,
+            tmdb_id: str(pids['Tmdb']),
+            imdb_id: str(pids['Imdb']),
+            played: ud['Played'] === true,
+            position_ticks: num(ud['PlaybackPositionTicks']) ?? 0,
+            overview: str(it['Overview']),
+            genres: Array.isArray(it['Genres']) ? it['Genres'].map(String) : [],
+            year: num(it['ProductionYear']),
+            runtime: ticks != null ? Math.round(ticks / 600_000_000) : null,
+            rating: num(it['CommunityRating']),
+            seasons: kind === 'series' ? num(it['ChildCount']) : null,
+            has_image: typeof tags['Primary'] === 'string',
+        });
+    }
+    return out;
+}
+export function itemLink(creds, jellyfinId) {
+    return `${creds.url.replace(/\/$/, '')}/web/#/details?id=${jellyfinId}`;
+}
+export function imageUrl(creds, jellyfinId) {
+    return `${creds.url.replace(/\/$/, '')}/Items/${jellyfinId}/Images/Primary?maxWidth=500`;
+}
+export async function fetchLibrary(creds, fetchFn = fetch) {
+    const base = creds.url.replace(/\/$/, '');
+    const fields = 'ProviderIds,UserData,Overview,Genres,ProductionYear,RunTimeTicks,CommunityRating,ChildCount';
+    const url = `${base}/Users/${creds.userId}/Items?Recursive=true&IncludeItemTypes=Movie,Series&Fields=${fields}`;
+    const resp = await fetchFn(url, { headers: { 'X-Emby-Token': creds.token, Accept: 'application/json' } });
+    if (!resp.ok)
+        throw new Error(`Jellyfin returned ${resp.status}`);
+    return normalizeItems(await resp.json());
+}
+export async function testConnection(url, token, fetchFn = fetch) {
+    try {
+        const resp = await fetchFn(`${url.replace(/\/$/, '')}/System/Info`, {
+            headers: { 'X-Emby-Token': token, Accept: 'application/json' },
+        });
+        return resp.ok ? { ok: true } : { ok: false, error: `Jellyfin returned ${resp.status}` };
+    }
+    catch (e) {
+        return { ok: false, error: e.message };
+    }
+}

package/dist/runtime/omdb.d.ts

@@ -0,0 +1 @@
+export declare function getRating(imdbId: string, key: string | undefined, fetchFn?: typeof fetch): Promise<number | null>;

package/dist/runtime/omdb.js

@@ -0,0 +1,15 @@
+export async function getRating(imdbId, key, fetchFn = fetch) {
+    if (!key || !imdbId)
+        return null;
+    try {
+        const resp = await fetchFn(`https://www.omdbapi.com/?apikey=${key}&i=${encodeURIComponent(imdbId)}`);
+        if (!resp.ok)
+            return null;
+        const json = (await resp.json());
+        const n = Number.parseFloat(json.imdbRating ?? '');
+        return Number.isFinite(n) ? n : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/runtime/sync.d.ts

@@ -0,0 +1,25 @@
+import { type JfItem } from './jellyfin.ts';
+export interface ExistingTitle {
+    id: number;
+    tmdb_id?: string | null;
+    imdb_id?: string | null;
+    jellyfin_id?: string | null;
+    status?: string | null;
+    poster?: unknown;
+}
+export type SyncOp = {
+    kind: 'create';
+    id?: undefined;
+    jellyfin_id: string;
+    rec: Record<string, unknown>;
+} | {
+    kind: 'update';
+    id: number;
+    jellyfin_id: string;
+    rec: Record<string, unknown>;
+};
+export declare function planSync(items: JfItem[], existing: ExistingTitle[], baseUrl: string): SyncOp[];
+export declare function runJellyfinSync(fetchFn?: typeof fetch): Promise<{
+    created: number;
+    updated: number;
+}>;

package/dist/runtime/sync.js

@@ -0,0 +1,86 @@
+import { getPluginSettings } from '@coffer-org/server/plugin-runtime';
+import { getModule } from '@coffer-org/server/registry-context';
+import { moduleTableName } from '@coffer-org/server/entity-schema';
+import { listRecords } from '@coffer-org/server/mutate';
+import { localPost, localPatch } from '@coffer-org/server/local-api';
+import { fetchLibrary, itemLink, imageUrl } from "./jellyfin.js";
+import { downloadImage } from "./files.js";
+const VAULT = 'media';
+const MODULE = 'title';
+function statusFor(it) {
+    if (it.played)
+        return 'watched';
+    if (it.position_ticks > 0)
+        return 'watching';
+    return 'unwatched';
+}
+function findMatch(it, link, existing) {
+    return (existing.find((e) => e.jellyfin_id === link) ||
+        (it.tmdb_id ? existing.find((e) => e.tmdb_id === it.tmdb_id) : undefined) ||
+        (it.imdb_id ? existing.find((e) => e.imdb_id === it.imdb_id) : undefined) ||
+        undefined);
+}
+export function planSync(items, existing, baseUrl) {
+    const ops = [];
+    for (const it of items) {
+        const link = itemLink({ url: baseUrl }, it.jellyfin_id);
+        const match = findMatch(it, link, existing);
+        const rec = {
+            name: it.name,
+            kind: it.kind,
+            tmdb_id: it.tmdb_id ?? undefined,
+            imdb_id: it.imdb_id ?? undefined,
+            jellyfin_id: link,
+            in_library: true,
+            source: 'jellyfin',
+            status: statusFor(it),
+            overview: it.overview ?? undefined,
+            genres: it.genres,
+            year: it.year ?? undefined,
+            runtime: it.runtime ?? undefined,
+            imdb_rating: it.rating ?? undefined,
+            seasons: it.seasons ?? undefined,
+        };
+        if (match)
+            ops.push({ kind: 'update', id: match.id, jellyfin_id: it.jellyfin_id, rec });
+        else
+            ops.push({ kind: 'create', jellyfin_id: it.jellyfin_id, rec });
+    }
+    return ops;
+}
+export async function runJellyfinSync(fetchFn = fetch) {
+    const s = await getPluginSettings('media');
+    const url = s['jellyfin_url'];
+    const token = s['jellyfin_token'];
+    const userId = s['jellyfin_user_id'];
+    if (!url || !token || !userId) {
+        throw new Error('Jellyfin settings not configured. Save URL, token and user id first.');
+    }
+    if (!getModule(VAULT, MODULE))
+        throw new Error('media vault not registered');
+    const creds = { url, token, userId };
+    const items = await fetchLibrary(creds, fetchFn);
+    const byJf = new Map(items.map((i) => [i.jellyfin_id, i]));
+    const ename = moduleTableName(VAULT, MODULE);
+    const existing = (await listRecords(ename));
+    let created = 0;
+    let updated = 0;
+    for (const op of planSync(items, existing, url)) {
+        const it = byJf.get(op.jellyfin_id);
+        const had = op.kind === 'update' && existing.find((e) => e.id === op.id)?.poster;
+        if (it?.has_image && !had) {
+            const poster = await downloadImage(imageUrl(creds, it.jellyfin_id), { 'X-Emby-Token': token }, fetchFn);
+            if (poster)
+                op.rec['poster'] = poster;
+        }
+        if (op.kind === 'update') {
+            await localPatch(VAULT, MODULE, op.id, op.rec);
+            updated++;
+        }
+        else {
+            await localPost(VAULT, MODULE, op.rec);
+            created++;
+        }
+    }
+    return { created, updated };
+}

package/dist/runtime/tmdb.d.ts

@@ -0,0 +1,21 @@
+export interface TmdbCandidate {
+    tmdb_id: string;
+    kind: 'movie' | 'series';
+    name: string;
+    year: number | null;
+    poster: string | null;
+    overview: string;
+}
+export interface TitleDetails extends TmdbCandidate {
+    genres: string[];
+    runtime: number | null;
+    tmdb_rating: number | null;
+    imdb_id: string | null;
+    seasons: number | null;
+    episodes: number | null;
+    link: string | null;
+}
+export declare function normalizeSearch(raw: unknown): TmdbCandidate[];
+export declare function normalizeDetails(raw: unknown, kind: 'movie' | 'series'): TitleDetails;
+export declare function searchTitle(query: string, key: string, kind?: 'movie' | 'series', fetchFn?: typeof fetch): Promise<TmdbCandidate[]>;
+export declare function getDetails(tmdbId: string, kind: 'movie' | 'series', key: string, fetchFn?: typeof fetch): Promise<TitleDetails>;

package/dist/runtime/tmdb.js

@@ -0,0 +1,65 @@
+const IMG = 'https://image.tmdb.org/t/p/w500';
+const API = 'https://api.themoviedb.org/3';
+const yearOf = (d) => typeof d === 'string' && d.length >= 4 ? Number(d.slice(0, 4)) : null;
+const posterOf = (p) => (typeof p === 'string' && p ? `${IMG}${p}` : null);
+function candidate(r, kind) {
+    return {
+        tmdb_id: String(r['id']),
+        kind,
+        name: String(r['title'] ?? r['name'] ?? ''),
+        year: yearOf(r['release_date'] ?? r['first_air_date']),
+        poster: posterOf(r['poster_path']),
+        overview: String(r['overview'] ?? ''),
+    };
+}
+export function normalizeSearch(raw) {
+    const results = raw?.['results'] ?? [];
+    const out = [];
+    for (const r of results) {
+        const mt = r['media_type'];
+        if (mt === 'movie')
+            out.push(candidate(r, 'movie'));
+        else if (mt === 'tv')
+            out.push(candidate(r, 'series'));
+    }
+    return out;
+}
+export function normalizeDetails(raw, kind) {
+    const r = raw;
+    const base = candidate(r, kind);
+    const genres = (r['genres'] ?? []).map((g) => String(g['name'])).filter(Boolean);
+    const ext = r['external_ids'] ?? {};
+    const va = r['vote_average'];
+    return {
+        ...base,
+        genres,
+        runtime: typeof r['runtime'] === 'number' ? r['runtime'] : null,
+        tmdb_rating: typeof va === 'number' && va > 0 ? va : null,
+        imdb_id: (typeof ext['imdb_id'] === 'string' && ext['imdb_id']) || null,
+        seasons: typeof r['number_of_seasons'] === 'number' ? r['number_of_seasons'] : null,
+        episodes: typeof r['number_of_episodes'] === 'number' ? r['number_of_episodes'] : null,
+        link: `https://www.themoviedb.org/${kind === 'movie' ? 'movie' : 'tv'}/${base.tmdb_id}`,
+    };
+}
+export async function searchTitle(query, key, kind, fetchFn = fetch) {
+    const path = kind ? (kind === 'movie' ? 'search/movie' : 'search/tv') : 'search/multi';
+    const url = `${API}/${path}?api_key=${key}&query=${encodeURIComponent(query)}`;
+    const resp = await fetchFn(url);
+    if (!resp.ok)
+        throw new Error(`TMDB search returned ${resp.status}`);
+    const json = await resp.json();
+    if (kind) {
+        const mt = kind === 'movie' ? 'movie' : 'tv';
+        for (const r of json['results'] ?? [])
+            r['media_type'] = mt;
+    }
+    return normalizeSearch(json);
+}
+export async function getDetails(tmdbId, kind, key, fetchFn = fetch) {
+    const seg = kind === 'movie' ? 'movie' : 'tv';
+    const url = `${API}/${seg}/${tmdbId}?api_key=${key}&append_to_response=external_ids`;
+    const resp = await fetchFn(url);
+    if (!resp.ok)
+        throw new Error(`TMDB details returned ${resp.status}`);
+    return normalizeDetails(await resp.json(), kind);
+}

package/dist/title/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@coffer-org/sdk/module").ModuleDef;
+export default _default;

package/dist/title/index.js

@@ -0,0 +1,63 @@
+import { defineModule } from '@coffer-org/sdk/module';
+import { field } from '@coffer-org/sdk/fields';
+export default defineModule({
+    module: 'title',
+    vault: 'media',
+    label: 'media.title.label',
+    icon: 'lucide:clapperboard',
+    claude: 'A movie or series in the watchlist. name — the title. kind — movie/series. status — viewing intent ' +
+        '(want=added to the list, not in Jellyfin yet / unwatched=in Jellyfin, not watched / watching / watched / dropped). ' +
+        'in_library, jellyfin_id and source are mirrored from Jellyfin — ' +
+        'do not edit manually when source=jellyfin (sync will overwrite).',
+    views: {
+        table: ['kind', 'status', 'year', 'imdb_rating'],
+        groupBy: ['kind', 'status', 'genres', 'year', 'source'],
+    },
+    fields: [
+        field.title({ key: 'name', label: 'core.fields.name' }),
+        field.image({ key: 'poster', label: 'media.title.fields.poster' }),
+        field.text({ key: 'overview', label: 'media.title.fields.overview', rules: { max: 2000 } }),
+        field.select({
+            key: 'kind',
+            label: 'media.title.fields.kind',
+            options: [
+                { value: 'movie', title: 'media.title.options.kind.movie' },
+                { value: 'series', title: 'media.title.options.kind.series' },
+            ],
+        }),
+        field.int({ key: 'year', label: 'media.title.fields.year' }),
+        field.tags({ key: 'genres', label: 'media.title.fields.genres' }),
+        field.duration({ key: 'runtime', label: 'media.title.fields.runtime' }),
+        field.string({ key: 'tmdb_id', label: 'media.title.fields.tmdb_id', rules: { max: 32 } }),
+        field.string({ key: 'imdb_id', label: 'media.title.fields.imdb_id', rules: { max: 32 } }),
+        field.real({ key: 'tmdb_rating', label: 'media.title.fields.tmdb_rating' }),
+        field.real({ key: 'imdb_rating', label: 'media.title.fields.imdb_rating' }),
+        field.select({
+            key: 'status',
+            label: 'media.title.fields.status',
+            options: [
+                { value: 'want', title: 'media.title.options.status.want' },
+                { value: 'unwatched', title: 'media.title.options.status.unwatched' },
+                { value: 'watching', title: 'media.title.options.status.watching' },
+                { value: 'watched', title: 'media.title.options.status.watched' },
+                { value: 'dropped', title: 'media.title.options.status.dropped' },
+            ],
+        }),
+        field.date({ key: 'watched_date', label: 'media.title.fields.watched_date' }),
+        field.int({ key: 'seasons', label: 'media.title.fields.seasons', rules: { min: 0 } }),
+        field.int({ key: 'episodes', label: 'media.title.fields.episodes', rules: { min: 0 } }),
+        field.boolean({ key: 'in_library', label: 'media.title.fields.in_library' }),
+        field.string({ key: 'jellyfin_id', label: 'media.title.fields.jellyfin_id', rules: { max: 300 } }),
+        field.select({
+            key: 'source',
+            label: 'media.title.fields.source',
+            default: 'manual',
+            options: [
+                { value: 'manual', title: 'media.title.options.source.manual' },
+                { value: 'jellyfin', title: 'media.title.options.source.jellyfin' },
+                { value: 'agent', title: 'media.title.options.source.agent' },
+            ],
+        }),
+        field.url({ key: 'link', label: 'media.title.fields.link' }),
+    ],
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@coffer-org/plugin-media",
+  "version": "1.2.0",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "prepack": "npm run build && node ../../scripts/swap-exports.mjs dist",
+    "postpack": "node ../../scripts/swap-exports.mjs src",
+    "test": "node --import tsx/esm --test 'src/runtime/*.test.ts'"
+  },
+  "dependencies": {
+    "@coffer-org/sdk": "^1.2.0",
+    "@coffer-org/server": "^1.2.0",
+    "zod": "^4.4.3"
+  }
+}