pixivflow 2.16.0 → 2.16.1

package/node_modules/@redtidev/pixiv-client/dist/web-api/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/web-api/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAExD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;CAC/B"}

package/node_modules/@redtidev/pixiv-client/dist/web-api/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/node_modules/@redtidev/pixiv-client/dist/web-api/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/web-api/types.ts"],"names":[],"mappings":""}

package/node_modules/@redtidev/pixiv-client/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@redtidev/pixiv-client",
+  "version": "0.1.0",
+  "description": "Independent, reusable Pixiv App-API client kit: typed transport, rate limiting, circuit breaker, pagination and media fetch. Knows Pixiv, knows nothing about the host application.",
+  "license": "MIT",
+  "author": "redtidev1918",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/redtidev1918/PixivFlow.git",
+    "directory": "packages/pixiv-client"
+  },
+  "keywords": [
+    "pixiv",
+    "pixiv-api",
+    "pixiv-client",
+    "api-client",
+    "rate-limiting",
+    "circuit-breaker",
+    "typescript"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest --runInBand",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "axios": "^1.20.0",
+    "socks-proxy-agent": "^8.0.5",
+    "undici": "^6.28.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^22.20.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.12",
+    "typescript": "^5.6.2"
+  }
+}

package/node_modules/@redtidev/pixiv-client/src/__tests__/independence.test.ts

@@ -0,0 +1,75 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, resolve, dirname, relative } from 'node:path';
+
+/**
+ * Architectural guard: the kit must stay independent of PixivFlow.
+ * The package lives in a workspace but may only depend on its own declared
+ * deps; any import reaching into the host product breaks reuse/split-out.
+ */
+describe('kit independence', () => {
+  const root = join(__dirname, '..');
+  const files: string[] = [];
+  const walk = (dir: string) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name === '__tests__' || entry.name === 'node_modules') continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.name.endsWith('.ts')) files.push(full);
+    }
+  };
+  const srcRoot = root; // __dirname/.. is src/ under ts-jest
+  walk(srcRoot);
+
+  it('never imports PixivFlow product symbols', () => {
+    const forbiddenSubstrings = [
+      'TargetConfig',
+      'StandaloneConfig',
+      'better-sqlite3',
+      'puppeteer',
+      'playwright',
+    ];
+    const violations: string[] = [];
+    for (const file of files) {
+      const rel = file.replace(root, '.');
+      // Strip comments: JSDoc deliberately names forbidden host concepts to
+      // document the boundary; the guard is about real code/imports.
+      const src = readFileSync(file, 'utf8')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/^\s*\/\/.*$/gm, '');
+      for (const banned of forbiddenSubstrings) {
+        if (src.includes(banned)) violations.push(`${rel} references ${banned}`);
+      }
+      for (const m of src.matchAll(/from\s+['"](\.[^'"]*)['"]/g)) {
+        const resolved = resolve(dirname(file), m[1]);
+        const inside = relative(srcRoot, resolved);
+        if (inside.startsWith('..')) {
+          violations.push(`${rel} relative import escapes src: ${m[1]}`);
+        }
+      }
+    }
+    expect(violations).toEqual([]);
+  });
+
+  it('declares every runtime dependency it imports', () => {
+    const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8')) as {
+      dependencies?: Record<string, string>;
+    };
+    const declared = new Set([...Object.keys(pkg.dependencies ?? {}), ...BUILTINS]);
+    const missing = new Set<string>();
+    for (const file of files) {
+      const src = readFileSync(file, 'utf8');
+      for (const m of src.matchAll(/from\s+['"]([^'".][^'"]*)['"]/g)) {
+        let spec = m[1];
+        if (spec.startsWith('node:')) continue; // node builtin
+        const name = spec.startsWith('@') ? spec.split('/').slice(0, 2).join('/') : spec.split('/')[0];
+        if (!declared.has(name)) missing.add(name);
+      }
+    }
+    expect([...missing]).toEqual([]);
+  });
+});
+
+const BUILTINS = new Set([
+  'crypto', 'events', 'fs', 'http', 'https', 'net', 'os', 'path',
+  'stream', 'timers', 'url', 'util', 'zlib',
+]);

package/node_modules/@redtidev/pixiv-client/src/__tests__/integration.test.ts

@@ -0,0 +1,268 @@
+import { PixivClient } from '../client';
+import { StaticTokenProvider } from '../auth/types';
+import { MemoryRateLimitStateStore } from '../rate-limit/RateLimitGate';
+import { paginate } from '../pagination';
+import type { FetchLike, RateLimitStateStore } from '../types';
+import {
+  PixivCircuitOpenError,
+  PixivRateLimitError,
+  PixivAbortError,
+} from '../errors/errors';
+
+function response(status: number, body: unknown, headers: Record<string, string> = {}) {
+  const text = typeof body === 'string' ? body : JSON.stringify(body);
+  const map = new Map(Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]));
+  return {
+    status,
+    statusText: '',
+    ok: status >= 200 && status < 300,
+    headers: { get: (n: string) => map.get(n.toLowerCase()) ?? null },
+    json: async () => JSON.parse(text),
+    text: async () => text,
+    arrayBuffer: async () => new ArrayBuffer(0),
+  };
+}
+
+function clientWith(fetchImpl: FetchLike, store?: RateLimitStateStore) {
+  return new PixivClient({
+    auth: new StaticTokenProvider('t'),
+    fetchImpl,
+    retries: 0,
+    rateLimit: {
+      minIntervalMs: 0,
+      jitterRatio: 0,
+      initialCooldownMs: 1, // tiny: no real-time waiting in tests
+      maxCooldownMs: 600_000,
+      random: () => 0,
+      stateStore: store,
+      // No real waiting: gate cooldowns resolve immediately (state still
+      // records the full cooldownUntil, which is what restart recovery tests).
+      sleep: (ms) => new Promise<void>((resolve) => setTimeout(resolve, 0)),
+    },
+  });
+}
+
+describe('restart recovery', () => {
+  it('429 -> cooldown persisted -> new client with same store still blocks', async () => {
+    const store = new MemoryRateLimitStateStore();
+    let calls = 0;
+    const client = clientWith(
+      async () => {
+        calls++;
+        return response(429, { error: 'rate' }, { 'retry-after': '60' });
+      },
+      store
+    );
+    await expect(client.illustrations.get(1)).rejects.toBeInstanceOf(PixivRateLimitError);
+
+    // "Restart": a brand new client, same persisted state.
+    let calls2 = 0;
+    const client2 = clientWith(async () => {
+      calls2++;
+      return response(200, { illust: { id: 1 } });
+    }, store);
+
+    const status = await client2.getRateLimitStatus();
+    expect(status.cooldownRemainingMs).toBeGreaterThanOrEqual(50_000);
+    expect(status.penaltyLevel).toBe(1);
+    expect(calls2).toBe(0); // no request attempted before any call
+
+    // At the persisted cooldown instant the next request is gated (waits);
+    // after advancing the clock past it, it goes through without a reset.
+    let nowMs = Date.now();
+    const client3 = new PixivClient({
+      auth: new StaticTokenProvider('t'),
+      fetchImpl: async () => {
+        calls2++;
+        return response(200, { illust: { id: 1 } });
+      },
+      retries: 0,
+      rateLimit: {
+        minIntervalMs: 0,
+        jitterRatio: 0,
+        initialCooldownMs: 1,
+        maxCooldownMs: 600_000,
+        random: () => 0,
+        stateStore: store,
+        now: () => nowMs,
+      },
+    });
+    const st = await client3.getRateLimitStatus();
+    expect(st.circuitState).toBe('closed');
+    expect(st.cooldownRemainingMs).toBeGreaterThan(0);
+    // Jump beyond the persisted cooldown: request now succeeds, proving the
+    // block came from persisted state, not a fresh clock-zero default.
+    nowMs += 120_000;
+    expect((await client3.illustrations.get(1)).id).toBe(1);
+    expect(calls2).toBe(1);
+  });
+});
+
+describe('429 queue serialization (fault injection)', () => {
+  it('search 429 parks the global gate; after cooldown, queued sends are spaced 1s apart', async () => {
+    // Deterministic virtual clock: sleeps resolve in fake-time order and the
+    // event loop drains all queued continuations.
+    let now = 1_000_000;
+    let seq = 0;
+    const timers: Array<{ at: number; seq: number; resolve: () => void; reject: (e: unknown) => void }> = [];
+    const sleep = (ms: number, signal?: AbortSignal) =>
+      new Promise<void>((resolve, reject) => {
+        const entry = { at: now + ms, seq: seq++, resolve, reject };
+        timers.push(entry);
+        signal?.addEventListener(
+          'abort',
+          () => {
+            const i = timers.indexOf(entry);
+            if (i >= 0) timers.splice(i, 1);
+            reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+          },
+          { once: true }
+        );
+      });
+    const run = async (deadline: number) => {
+      // Fire timers in chronological order, jumping fake time to each one;
+      // drain continuations after every fire so chains that register a NEW
+      // timer (retry sleeps, queued slots) are seen on the next iteration.
+      for (let safety = 0; safety < 10_000; safety++) {
+        for (let i = 0; i < 30; i++) await new Promise((r) => setImmediate(r));
+        timers.sort((a, b) => a.at - b.at || a.seq - b.seq);
+        const next = timers[0];
+        if (!next || next.at > deadline) break;
+        timers.shift();
+        now = next.at;
+        next.resolve();
+      }
+    };
+
+    const sendTimes: number[] = [];
+    let searches = 0;
+    const client = new PixivClient({
+      auth: new StaticTokenProvider('t'),
+      retries: 2,
+      fetchImpl: async (url) => {
+        sendTimes.push(now);
+        const u = new URL(url);
+        if (u.pathname === '/v1/search/illust') {
+          searches++;
+          // Retry-After (30s) beats the short 10s ladder and sets the gate.
+          return searches <= 1 ? response(429, {}, { 'retry-after': '30' }) : response(200, { illusts: [], next_url: null });
+        }
+        return response(200, { illust: { id: Number(u.searchParams.get('illust_id')) } });
+      },
+      rateLimit: {
+        minIntervalMs: 1000,
+        jitterRatio: 0,
+        initialCooldownMs: 10_000,
+        maxCooldownMs: 600_000,
+        random: () => 0,
+        now: () => now,
+        sleep,
+      },
+      sleep,
+    });
+
+    // search gets a 429 (Retry-After 30s), retries after the gate cooldown.
+    const searchP = client.illustrations.search({ word: 'x', limit: 1 });
+    // Two details arrive concurrently; they must wait behind the gate, not fire.
+    const detailP = [2, 3].map((id) => client.illustrations.get(id));
+
+    await run(now + 60_000);
+
+    const searchResult = await searchP;
+    expect(searchResult.items).toEqual([]);
+    const details = await Promise.all(detailP);
+    expect(details.map((d) => d.id)).toEqual([2, 3]);
+
+    // Attempt 1 at t0 429s; the global gate parks EVERYTHING until +30s (the
+    // details do not fire at +1s/+2s as they would without the shared gate).
+    // After the cooldown all three remaining sends are strictly 1s apart.
+    expect(sendTimes[0]).toBe(1_000_000);
+    expect(sendTimes.slice(1)).toEqual([1_030_000, 1_031_000, 1_032_000]);
+  });
+});
+
+describe('pagination + abort', () => {
+  it('paginate walks next cursors and respects limit/maxPages', async () => {
+    const seen: number[] = [];
+    const result = await paginate<number>(
+      async (cursor) => {
+        const page = cursor ? Number(cursor) : 1;
+        seen.push(page);
+        return { items: [page, page], next: page < 3 ? String(page + 1) : null };
+      },
+      { limit: 5 }
+    );
+    expect(result.items).toEqual([1, 1, 2, 2, 3]);
+    expect(seen).toEqual([1, 2, 3]);
+  });
+
+  it('aborts a pagination walk', async () => {
+    const controller = new AbortController();
+    let pages = 0;
+    const p = paginate<number>(
+      async () => {
+        pages++;
+        if (pages === 2) controller.abort();
+        return { items: [1], next: 'more' };
+      },
+      { signal: controller.signal, maxPages: 10 }
+    );
+    const result = await p;
+    expect(pages).toBe(2);
+    expect(result.items).toHaveLength(2);
+  });
+
+  it('aborting a rate-limit wait rejects with PixivAbortError', async () => {
+    let now = 0;
+    const client = new PixivClient({
+      auth: new StaticTokenProvider('t'),
+      fetchImpl: (async () => response(200, { illust: { id: 1 } })) as FetchLike,
+      rateLimit: {
+        minIntervalMs: 10_000,
+        jitterRatio: 0,
+        random: () => 0,
+        now: () => now,
+        sleep: (ms, signal) =>
+          new Promise<void>((_resolve, reject) => {
+            signal?.addEventListener(
+              'abort',
+              () => reject(Object.assign(new Error('aborted'), { name: 'AbortError' })),
+              { once: true }
+            );
+          }),
+      },
+    });
+    // Consume the immediate first slot, then abort the second reservation.
+    void client.illustrations.get(1);
+    await Promise.resolve();
+    await Promise.resolve();
+    const controller = new AbortController();
+    const p = client.illustrations.get(2, controller.signal);
+    await Promise.resolve();
+    await Promise.resolve();
+    controller.abort();
+    await expect(p).rejects.toBeInstanceOf(PixivAbortError);
+  });
+
+  it('a top-level injected sleep also drives the gate pacing wait', async () => {
+    // Regression: the gate and the transport sleep in different layers; a host
+    // that injects one sleeper must not get real timers from the other (an
+    // unref'd default timer silently dropped requests in short-lived CLIs).
+    const sleepCalls: number[] = [];
+    let now = 0;
+    const client = new PixivClient({
+      auth: new StaticTokenProvider('t'),
+      fetchImpl: (async () => response(200, { illust: { id: 1 } })) as FetchLike,
+      sleep: (ms: number) => {
+        sleepCalls.push(ms);
+        now += ms;
+        return Promise.resolve();
+      },
+      rateLimit: { minIntervalMs: 1000, jitterRatio: 0, random: () => 0, now: () => now },
+    });
+    await client.illustrations.get(1);
+    await client.illustrations.get(2);
+    // The second request had to wait out the pacing interval at the gate.
+    expect(sleepCalls).toContain(1000);
+  });
+});

package/node_modules/@redtidev/pixiv-client/src/app-api/__tests__/services.test.ts

@@ -0,0 +1,199 @@
+import { PixivClient } from '../../client';
+import { StaticTokenProvider } from '../../auth/types';
+import type { FetchLike } from '../../types';
+import { PixivApiError, PixivNotFoundError } from '../../errors/errors';
+
+interface Call {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+}
+
+function jsonClient(handler: (url: URL, call: Call) => unknown | Promise<unknown>) {
+  const calls: Call[] = [];
+  const fetchImpl: FetchLike = async (url, init) => {
+    const u = new URL(url);
+    const call: Call = { url, method: (init.method as string) ?? 'GET', headers: init.headers as Record<string, string> };
+    calls.push(call);
+    const data = await handler(u, call);
+    const body = typeof data === 'string' ? data : JSON.stringify(data);
+    return {
+      status: 200,
+      statusText: 'OK',
+      ok: true,
+      headers: { get: () => null },
+      json: async () => JSON.parse(body),
+      text: async () => body,
+      arrayBuffer: async () => new ArrayBuffer(0),
+    };
+  };
+  const client = new PixivClient({
+    auth: new StaticTokenProvider('tok'),
+    fetchImpl,
+    rateLimit: { minIntervalMs: 0, jitterRatio: 0, random: () => 0, initialCooldownMs: 1000 },
+  });
+  return { client, calls };
+}
+
+describe('IllustrationsApi', () => {
+  it('detail / get hit v1/illust/detail', async () => {
+    const { client, calls } = jsonClient(() => ({ illust: { id: 5 } }));
+    const illust = await client.illustrations.get(5);
+    expect(illust.id).toBe(5);
+    expect(calls[0].url).toContain('/v1/illust/detail?illust_id=5');
+    expect(calls[0].headers.Authorization).toBe('Bearer tok');
+  });
+
+  it('searchPage maps IllustSearchOptions to Pixiv params (r18 omits filter, dates sent)', async () => {
+    const { client, calls } = jsonClient((u) => ({
+      illusts: [{ id: 1 }, { id: 2 }],
+      next_url: u.searchParams.get('start_date') ? `${u.origin}${u.pathname}?illust_id=next` : null,
+    }));
+    const page = await client.illustrations.searchPage({
+      word: 'cat',
+      sort: 'date_asc',
+      searchTarget: 'exact_match_for_tags',
+      includeR18: true,
+      startDate: '2024-01-01',
+      endDate: '2024-01-31',
+    });
+    expect(page.items).toHaveLength(2);
+    const u = new URL(calls[0].url);
+    expect(u.searchParams.get('word')).toBe('cat');
+    expect(u.searchParams.get('sort')).toBe('date_asc');
+    expect(u.searchParams.get('search_target')).toBe('exact_match_for_tags');
+    expect(u.searchParams.get('filter')).toBeNull();
+    expect(u.searchParams.get('start_date')).toBe('2024-01-01');
+    expect(u.searchParams.get('end_date')).toBe('2024-01-31');
+  });
+
+  it('search walks next_url until limit', async () => {
+    const { client, calls } = jsonClient((u) => {
+      const page = Number(u.searchParams.get('p') ?? '1');
+      return { illusts: [{ id: page * 10 }, { id: page * 10 + 1 }], next_url: `https://x/v1/search/illust?p=${page + 1}` };
+    });
+    const result = await client.illustrations.search({ word: 'dog', limit: 3 });
+    expect(result.items.map((i) => i.id)).toEqual([10, 11, 20]);
+    // Page 2 still advertises a cursor; the caller decides whether to walk on.
+    expect(result.nextCursor).toContain('p=3');
+    expect(calls).toHaveLength(2);
+  });
+
+  it('ranking walks next_url and respects limit', async () => {
+    const { client, calls } = jsonClient((u) => {
+      const page = Number(u.searchParams.get('p') ?? '1');
+      return { illusts: [{ id: page }], next_url: page < 3 ? `https://x/v1/illust/ranking?p=${page + 1}` : null };
+    });
+    const items = await client.illustrations.ranking('week', { date: '2024-01-01', limit: 2 });
+    expect(items).toHaveLength(2);
+    expect(new URL(calls[0].url).searchParams.get('mode')).toBe('week');
+  });
+
+  it('listByUser paginates and slices to limit', async () => {
+    const { client } = jsonClient((u) => {
+      const page = Number(u.searchParams.get('p') ?? '1');
+      return { illusts: [{ id: page }], next_url: page < 3 ? `https://x/v1/user/illusts?p=${page + 1}` : null };
+    });
+    const items = await client.illustrations.listByUser('99', { limit: 2 });
+    expect(items.map((i) => i.id)).toEqual([1, 2]);
+  });
+
+  it('ugoiraMetadata unwraps ugoira_metadata', async () => {
+    const { client } = jsonClient(() => ({
+      ugoira_metadata: { zip_urls: { medium: 'm' }, frames: [{ file: '000.jpg', delay: 60 }] },
+    }));
+    const meta = await client.illustrations.ugoiraMetadata(42);
+    expect(meta.frames[0].delay).toBe(60);
+    expect(meta.zip_urls.medium).toBe('m');
+  });
+});
+
+describe('NovelsApi', () => {
+  it('detail hits v2; detailCompatible/detailWithTags fall back to v1 on a missing endpoint', async () => {
+    const client1 = jsonClient(() => ({ novel: { id: 1 } })).client;
+    expect((await client1.novels.detail(1)).id).toBe(1);
+
+    const client2 = jsonClient((u) => {
+      if (u.pathname === '/v2/novel/detail') {
+        return Promise.reject(new PixivNotFoundError('Pixiv API error: 404 Not Found', { endpoint: u.href }));
+      }
+      return { novel: { id: 7, tags: [{ name: 't' }] } };
+    }).client;
+    expect((await client2.novels.detailCompatible(7)).id).toBe(7);
+    const withTags = await client2.novels.detailWithTags(7);
+    expect(withTags.tags).toEqual([{ name: 't' }]);
+    expect(withTags.novel.id).toBe(7);
+  });
+
+  it('text uses the webview marker chain first', async () => {
+    // The parser looks for 'novel: ' and slices until the next ',\n'.
+    const html = `prefix\nnovel: {"text":"hello"},\nrest`;
+    const { client, calls } = jsonClient(() => html);
+    const res = await client.novels.text(3);
+    expect(res.novel_text).toBe('hello');
+    expect(calls[0].url).toContain('/webview/v2/novel');
+  });
+
+  it('text falls through webview -> app-api -> www ajax, dropping the App Bearer for ajax', async () => {
+    let stage = 0;
+    const { client, calls } = jsonClient((u) => {
+      stage++;
+      if (u.pathname === '/webview/v2/novel') return 'no marker here';
+      if (u.pathname === '/v1/novel/text') return { novel_text: '   ' };
+      if (u.hostname === 'www.pixiv.net') return { error: false, body: { content: 'ajax-body' } };
+      throw new Error('unexpected ' + u.href);
+    });
+    const res = await client.novels.text(9);
+    expect(res.novel_text).toBe('ajax-body');
+    const ajaxCall = calls.find((c) => c.url.includes('www.pixiv.net'))!;
+    expect(ajaxCall.headers.Authorization).toBeUndefined();
+    expect(ajaxCall.headers['App-OS']).toBeUndefined();
+    expect(ajaxCall.headers.Referer).toBe('https://www.pixiv.net/');
+  });
+
+  it('text throws PixivApiError when every endpoint fails', async () => {
+    const client = jsonClient(() => '').client;
+    await expect(client.novels.text(11)).rejects.toBeInstanceOf(PixivApiError);
+  });
+
+  it('ranking and user novels paginate', async () => {
+    const { client } = jsonClient((u) => {
+      if (u.pathname === '/v1/novel/ranking') {
+        const page = Number(u.searchParams.get('p') ?? '1');
+        return { novels: [{ id: page }], next_url: page < 2 ? `https://x/v1/novel/ranking?p=${page + 1}` : null };
+      }
+      const page = Number(u.searchParams.get('p') ?? '1');
+      return { novels: [{ id: 100 + page }], next_url: page < 2 ? `https://x/v1/user/novels?p=${page + 1}` : null };
+    });
+    expect(await client.novels.ranking('day', { limit: 5 })).toHaveLength(2);
+    expect((await client.novels.listByUser('3', { limit: 1 })).map((n) => n.id)).toEqual([101]);
+  });
+
+  it('listSeries normalizes the series_content envelope and walks pages', async () => {
+    const { client } = jsonClient((u) => {
+      const page = Number(u.searchParams.get('p') ?? '1');
+      return {
+        novel_series_detail: {
+          series_content: [{ id: page, title: 't', user: { id: '1', name: 'u' }, create_date: '2024-01-01' }],
+        },
+        next_url: page < 2 ? `https://x/v1/novel/series?p=${page + 1}` : null,
+      };
+    });
+    const novels = await client.novels.listSeries(55);
+    expect(novels).toHaveLength(2);
+    expect(novels[0].user.name).toBe('u');
+  });
+});
+
+describe('TagsApi / UsersApi', () => {
+  it('autocomplete returns tag objects', async () => {
+    const { client } = jsonClient(() => ({ tags: [{ name: 'a' }, { name: 'b' }] }));
+    const tags = await client.tags.autocomplete('a');
+    expect(tags.map((t) => t.name)).toEqual(['a', 'b']);
+  });
+
+  it('users.user unwraps per-user detail', async () => {
+    const { client } = jsonClient(() => ({ user: { id: '42', name: 'someone' } }));
+    expect((await client.users.user(42)).id).toBe('42');
+  });
+});

package/node_modules/@redtidev/pixiv-client/src/app-api/exports.ts

@@ -0,0 +1,5 @@
+export { IllustrationsApi } from './illustrations';
+export { NovelsApi } from './novels';
+export { TagsApi } from './tags';
+export { MediaApi } from './media';
+export { UsersApi } from './users';