fimo 0.7.0-experimental.3 → 0.7.0-experimental.4

package/scripts/lib/release-core.test.ts

@@ -0,0 +1,147 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import {
+  computePublishVersion,
+  nextPrereleaseCounter,
+  nextVersionFromChangesets,
+  parsePublishedVersions,
+  // @ts-expect-error plain mjs module without types
+} from './release-core.mjs';
+
+const stagingChannel = { prerelease: true, distTag: 'staging' };
+const latestChannel = { prerelease: false, distTag: 'latest' };
+
+describe('computePublishVersion', () => {
+  it('returns the base version verbatim for stable channels', () => {
+    expect(computePublishVersion('0.3.3', latestChannel, { runId: '7' })).toBe('0.3.3');
+  });
+
+  it('synthesizes a prerelease version from the run id', () => {
+    expect(computePublishVersion('0.3.3', stagingChannel, { runId: '26' })).toBe('0.3.3-staging.26');
+  });
+
+  it('strips an existing prerelease suffix before synthesizing', () => {
+    expect(computePublishVersion('0.3.3-staging.9', stagingChannel, { runId: '26' })).toBe('0.3.3-staging.26');
+  });
+
+  it('counts per base version when published versions are provided', () => {
+    const existingVersions = ['0.3.4', '0.3.5-staging.1', '0.3.5-staging.2'];
+    expect(computePublishVersion('0.3.5', stagingChannel, { runId: '30', existingVersions })).toBe('0.3.5-staging.3');
+  });
+
+  it('starts at 1 for a base with no published prereleases', () => {
+    const existingVersions = ['0.3.4', '0.3.4-staging.26', '0.3.4-staging.27'];
+    expect(computePublishVersion('0.3.5', stagingChannel, { runId: '30', existingVersions })).toBe('0.3.5-staging.1');
+  });
+});
+
+describe('parsePublishedVersions', () => {
+  it('passes through the npm <= 11 array-of-strings shape', () => {
+    expect(parsePublishedVersions('["0.3.4", "0.3.5-staging.1"]')).toEqual(['0.3.4', '0.3.5-staging.1']);
+  });
+
+  it('wraps the npm <= 11 bare string returned for a single published version', () => {
+    expect(parsePublishedVersions('"0.0.0"')).toEqual(['0.0.0']);
+  });
+
+  it('unwraps the npm 12 shape (--json always returns an array)', () => {
+    expect(parsePublishedVersions('[["0.3.4", "0.3.5-staging.1", "0.3.5"]]')).toEqual([
+      '0.3.4',
+      '0.3.5-staging.1',
+      '0.3.5',
+    ]);
+  });
+
+  it('returns null for unparseable output', () => {
+    expect(parsePublishedVersions('')).toBeNull();
+    expect(parsePublishedVersions('npm ERR! something')).toBeNull();
+  });
+
+  it('returns null when nothing version-shaped survives (error envelopes, empty lists)', () => {
+    expect(parsePublishedVersions('{"error":{"code":"E401"}}')).toBeNull();
+    expect(parsePublishedVersions('[]')).toBeNull();
+    expect(parsePublishedVersions('[{"error":{"code":"E404"}}]')).toBeNull();
+    expect(parsePublishedVersions('null')).toBeNull();
+  });
+});
+
+describe('nextPrereleaseCounter', () => {
+  it('returns 1 when nothing matches the base + tag', () => {
+    expect(nextPrereleaseCounter([], '0.3.5', 'staging')).toBe(1);
+    expect(nextPrereleaseCounter(['0.3.5', '0.3.5-experimental.4'], '0.3.5', 'staging')).toBe(1);
+  });
+
+  it('continues past the highest published counter for the base', () => {
+    const versions = ['0.3.4-staging.26', '0.3.4-staging.27', '0.3.3-staging.25'];
+    expect(nextPrereleaseCounter(versions, '0.3.4', 'staging')).toBe(28);
+  });
+
+  it('does not confuse prefix-sharing bases (0.3.4 vs 0.3.40)', () => {
+    expect(nextPrereleaseCounter(['0.3.40-staging.9'], '0.3.4', 'staging')).toBe(1);
+  });
+
+  it('ignores non-integer counters (timestamps still count, garbage does not)', () => {
+    expect(nextPrereleaseCounter(['0.3.4-staging.abc', '0.3.4-staging.2.5'], '0.3.4', 'staging')).toBe(1);
+    expect(nextPrereleaseCounter(['0.3.3-experimental.1783410168478'], '0.3.3', 'experimental')).toBe(1783410168479);
+  });
+});
+
+describe('nextVersionFromChangesets', () => {
+  let dir: string;
+
+  afterEach(() => {
+    if (dir) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  function changesetDir(files: Record<string, string>): string {
+    dir = mkdtempSync(join(tmpdir(), 'changesets-'));
+    writeFileSync(join(dir, 'README.md'), '# Changesets\n');
+    for (const [name, frontmatter] of Object.entries(files)) {
+      writeFileSync(join(dir, name), `---\n${frontmatter}\n---\n\nsummary\n`);
+    }
+    return dir;
+  }
+
+  it('returns the base when the directory does not exist', () => {
+    expect(nextVersionFromChangesets('0.3.3', '/nonexistent/.changeset')).toBe('0.3.3');
+  });
+
+  it('returns the base when no changesets are pending', () => {
+    expect(nextVersionFromChangesets('0.3.3', changesetDir({}))).toBe('0.3.3');
+  });
+
+  it('applies a patch bump for pending patch changesets', () => {
+    const d = changesetDir({ 'a.md': "'fimo': patch" });
+    expect(nextVersionFromChangesets('0.3.3', d)).toBe('0.3.4');
+  });
+
+  it('takes the max bump across pending changesets', () => {
+    const d = changesetDir({
+      'a.md': "'fimo': patch",
+      'b.md': "'fimo': minor",
+      'c.md': "'fimo': patch",
+    });
+    expect(nextVersionFromChangesets('0.3.3', d)).toBe('0.4.0');
+  });
+
+  it('handles major bumps and double-quoted package names', () => {
+    const d = changesetDir({ 'a.md': '"fimo": major' });
+    expect(nextVersionFromChangesets('0.3.3', d)).toBe('1.0.0');
+  });
+
+  it('ignores changesets for other packages', () => {
+    const d = changesetDir({ 'a.md': "'@fimo/fimovm': minor" });
+    expect(nextVersionFromChangesets('0.3.3', d)).toBe('0.3.3');
+  });
+
+  it('ignores an existing prerelease suffix on the base', () => {
+    const d = changesetDir({ 'a.md': "'fimo': patch" });
+    expect(nextVersionFromChangesets('0.3.3-staging.9', d)).toBe('0.3.4');
+  });
+});

package/scripts/migration-qa-gate.test.ts

@@ -0,0 +1,155 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCRIPT = path.resolve(__dirname, '../assets/skills/fimo-migration/scripts/write-migration-report.mjs');
+
+interface GateResult {
+  status: number | null;
+  report: string;
+}
+
+let dir: string;
+
+beforeEach(() => {
+  dir = mkdtempSync(path.join(tmpdir(), 'fimo-qa-gate-'));
+});
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function runGate(manifest: unknown, opts: { withBuildArtifact?: boolean } = {}): GateResult {
+  mkdirSync(path.join(dir, '.fimo', 'migration'), { recursive: true });
+  writeFileSync(path.join(dir, '.fimo', 'migration', 'manifest.json'), JSON.stringify(manifest, null, 2));
+  if (opts.withBuildArtifact) {
+    mkdirSync(path.join(dir, 'dist', 'client'), { recursive: true });
+    writeFileSync(path.join(dir, 'dist', 'client', 'index.html'), '<html></html>');
+  }
+  const reportPath = path.join(dir, 'report.md');
+  const child = spawnSync(process.execPath, [SCRIPT, dir, '--no-update-manifest', '--output', reportPath], {
+    encoding: 'utf8',
+  });
+  return { status: child.status, report: readFileSync(reportPath, 'utf8') };
+}
+
+function statusLine(report: string): string {
+  const lines = report.split('\n');
+  const idx = lines.findIndex((line) => line.trim() === '## Status');
+  return lines[idx + 2]?.trim() ?? '';
+}
+
+function checkFailed(report: string, id: string): boolean {
+  return report.includes(`- [ ] `) && new RegExp(`- \\[ \\] .*\\(${id}\\)`).test(report);
+}
+
+describe('migration QA gate (write-migration-report.mjs)', () => {
+  it('fails generated-only entries even when seed JSON exists (no silent pass)', () => {
+    const { status, report } = runGate({
+      source: { mode: 'url-only', platform: 'wix' },
+      routes: [{ route: '/', status: 'verified' }],
+      contentTypes: [{ name: 'game', status: 'generated' }],
+      entries: [{ contentType: 'game', sourceCount: 11, generatedCount: 11, importedCount: 0 }],
+      media: [],
+      forms: [],
+      unresolved: [],
+    });
+    expect(status).toBe(1);
+    expect(statusLine(report)).toBe('draft-only');
+    expect(checkFailed(report, 'cms-counts')).toBe(true);
+    expect(checkFailed(report, 'schemas-pushed')).toBe(true);
+  });
+
+  it('fails referenced media that is only bundled locally under public/', () => {
+    const { status, report } = runGate({
+      source: { mode: 'url-only', platform: 'wix' },
+      routes: [{ route: '/', status: 'verified' }],
+      contentTypes: [],
+      entries: [],
+      media: [{ id: 'm1', referencedBy: ['/'], status: 'imported', targetUrl: '/assets/thepark/hero.webp' }],
+      forms: [],
+      unresolved: [],
+    });
+    expect(status).toBe(1);
+    expect(statusLine(report)).toBe('draft-only');
+    expect(checkFailed(report, 'media-covered')).toBe(true);
+    expect(report).toContain('Uploaded to Fimo: 0');
+    expect(report).toContain('Bundled locally (not uploaded): 1');
+  });
+
+  it('passes when entries are imported, schemas pushed, and media uploaded to Fimo', () => {
+    const { status, report } = runGate(
+      {
+        source: { mode: 'url-only', platform: 'wix' },
+        routes: [{ route: '/', status: 'verified' }],
+        contentTypes: [{ name: 'game', status: 'imported' }],
+        entries: [{ contentType: 'game', sourceCount: 3, generatedCount: 3, importedCount: 3, status: 'imported' }],
+        media: [
+          { id: 'm1', referencedBy: ['/'], targetAssetId: '11111111-1111-1111-1111-111111111111' },
+          {
+            id: 'm2',
+            referencedBy: ['/'],
+            targetUrl: 'https://assets.fimo.team/abc/hero.webp',
+            sourceUrl: 'https://static.wixstatic.com/hero.webp',
+          },
+        ],
+        forms: [],
+        unresolved: [],
+      },
+      { withBuildArtifact: true }
+    );
+    expect(status).toBe(0);
+    expect(statusLine(report)).toBe('complete');
+    expect(report).toContain('Uploaded to Fimo: 2');
+  });
+
+  it('rejects a target URL that merely echoes the source URL (nothing uploaded)', () => {
+    const { status, report } = runGate({
+      source: { mode: 'url-only', platform: 'wix' },
+      routes: [{ route: '/', status: 'verified' }],
+      contentTypes: [],
+      entries: [],
+      media: [
+        {
+          id: 'm1',
+          referencedBy: ['/'],
+          sourceUrl: 'https://static.wixstatic.com/hero.webp',
+          targetUrl: 'https://static.wixstatic.com/hero.webp',
+        },
+      ],
+      forms: [],
+      unresolved: [],
+    });
+    expect(status).toBe(1);
+    expect(checkFailed(report, 'media-covered')).toBe(true);
+  });
+
+  it('allows complete-with-unresolved when gaps are explicit, owner-visible unresolved items', () => {
+    const { status, report } = runGate(
+      {
+        source: { mode: 'url-only', platform: 'wix' },
+        routes: [{ route: '/', status: 'verified' }],
+        contentTypes: [{ name: 'game', status: 'unresolved' }],
+        entries: [{ contentType: 'game', sourceCount: 5, generatedCount: 5, importedCount: 0, status: 'unresolved' }],
+        media: [{ id: 'm1', referencedBy: ['/'], status: 'unresolved' }],
+        forms: [],
+        unresolved: [
+          {
+            severity: 'high',
+            area: 'cms',
+            message: 'Game entries need a source export before import.',
+            suggestedAction: 'Provide the Wix CMS export and re-run import.',
+          },
+        ],
+      },
+      { withBuildArtifact: true }
+    );
+    expect(status).toBe(0);
+    expect(statusLine(report)).toBe('complete-with-unresolved');
+  });
+});

package/scripts/publish-npm.mjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+// Publish the fimo CLI to npm on a channel.
+//
+// Usage:
+//   node scripts/publish-npm.mjs --channel experimental [--dry-run]
+//   node scripts/publish-npm.mjs --channel staging      [--dry-run]
+//   node scripts/publish-npm.mjs --channel latest       (CI only; --bootstrap for the first publish)
+//   node scripts/publish-npm.mjs --channel experimental --plan   (print the plan, touch nothing)
+//
+// What it does:
+//   1. Resolves the channel from the shared table (lib/channels.mjs).
+//   2. Guards: @latest refuses to publish outside CI unless --bootstrap.
+//   3. Builds in place (clean → build → build:bundle) with the workspace
+//      manifest UNTOUCHED, then `npm pack`s straight into a temp stage dir.
+//   4. Mutates ONLY the extracted stage copy: synthesized X.Y.Z-<tag>.<n>
+//      version, template fimo pin, channel release.json (allowlist-enforced —
+//      staging URLs for experimental/staging, prod for latest, never a tunnel).
+//   5. Runs `npm publish --tag <distTag>` from the stage (no --provenance —
+//      strapi/fimo is private).
+//   6. On real experimental publishes, records the exact version in repo-root
+//      .fimo/dev.json for local source-checkout deploys.
+//
+// The workspace is never mutated: no transient package.json version, no
+// release.json, no template rewrites — a crash or a long OTP prompt can't
+// leave the repo dirty (it used to sit mutated for the whole multi-minute
+// build + 2FA window).
+
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { resolveChannel } from './lib/channels.mjs';
+import { writeDevReleaseState } from './lib/dev-release-state.mjs';
+import {
+  computePublishVersion,
+  nextVersionFromChangesets,
+  parsePublishedVersions,
+  pinTemplateFimo,
+  stripTemplateLockfile,
+  writeReleaseJson,
+} from './lib/release-core.mjs';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const CLI_ROOT = resolve(HERE, '..');
+const PKG_PATH = resolve(CLI_ROOT, 'package.json');
+
+function parseArgs(argv) {
+  const args = { channel: null, dryRun: false, bootstrap: false, plan: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--channel') {
+      args.channel = argv[++i];
+    } else if (arg === '--dry-run') {
+      args.dryRun = true;
+    } else if (arg === '--bootstrap') {
+      args.bootstrap = true;
+    } else if (arg === '--plan') {
+      args.plan = true;
+    }
+  }
+  return args;
+}
+
+function run(cmd, args, cwd) {
+  console.log(`[publish-npm] $ ${cmd} ${args.join(' ')}`);
+  const result = spawnSync(cmd, args, { cwd, stdio: 'inherit' });
+  if (result.status !== 0) {
+    console.error(`[publish-npm] ${cmd} ${args[0]} failed (exit ${result.status}).`);
+    process.exit(result.status ?? 1);
+  }
+}
+
+// All published versions of the package, or null when the registry can't be
+// reached (offline, first-ever publish) or the output shape is unrecognized —
+// callers fall back to the run-number/timestamp counter.
+function fetchPublishedVersions(name) {
+  const result = spawnSync('npm', ['view', name, 'versions', '--json'], { encoding: 'utf8' });
+  if (result.status !== 0) {
+    return null;
+  }
+  return parsePublishedVersions(result.stdout);
+}
+
+const { channel: channelName, dryRun, bootstrap, plan } = parseArgs(process.argv.slice(2));
+
+if (!channelName) {
+  console.error('[publish-npm] missing --channel <experimental|staging|latest>');
+  process.exit(1);
+}
+
+const channel = resolveChannel(channelName);
+const isCI = !!process.env.CI;
+
+// Prod guard (D11): @latest never originates on a laptop.
+if (channel.distTag === 'latest' && !isCI && !bootstrap) {
+  console.error(
+    '[publish-npm] refusing to publish @latest outside CI.\n' +
+      '  Latest ships from CI on the production branch. For the first-ever publish, pass --bootstrap.'
+  );
+  process.exit(1);
+}
+
+const pkg = JSON.parse(readFileSync(PKG_PATH, 'utf8'));
+// Prerelease channels base off the version the pending changesets will
+// produce at the next production release, so a staging build advertises the
+// version prod will actually ship.
+const baseVersion = channel.prerelease
+  ? nextVersionFromChangesets(pkg.version, resolve(CLI_ROOT, '../../.changeset'))
+  : pkg.version;
+const runId = process.env.GITHUB_RUN_NUMBER;
+let existingVersions;
+if (channel.prerelease) {
+  existingVersions = fetchPublishedVersions(pkg.name) ?? undefined;
+  if (!existingVersions) {
+    console.warn('[publish-npm] could not fetch published versions from npm — using run/timestamp counter.');
+  }
+}
+const publishVersion = computePublishVersion(baseVersion, channel, { runId, existingVersions });
+
+console.log(`[publish-npm] channel:   ${channelName}  (dist-tag: ${channel.distTag})`);
+console.log(
+  `[publish-npm] version:   ${publishVersion}${publishVersion !== baseVersion ? ` (from ${baseVersion})` : ''}`
+);
+console.log(`[publish-npm] apiUrl:    ${channel.apiUrl}`);
+console.log(`[publish-npm] webUrl:    ${channel.webUrl}`);
+
+if (plan) {
+  console.log('[publish-npm] --plan: nothing written, nothing published.');
+  process.exit(0);
+}
+
+const stageRoot = mkdtempSync(join(tmpdir(), 'fimo-publish-'));
+try {
+  // 1. Build in place — the build output doesn't depend on the version, so
+  //    the workspace manifest stays untouched.
+  run('pnpm', ['run', 'prepublishOnly'], CLI_ROOT);
+
+  // 2. Pack the workspace tarball (honors the `files` whitelist) directly
+  //    into the stage dir; --ignore-scripts because we just built.
+  run('npm', ['pack', '--ignore-scripts', '--pack-destination', stageRoot], CLI_ROOT);
+  const tarball = readdirSync(stageRoot).find((name) => name.endsWith('.tgz'));
+  if (!tarball) {
+    console.error(`[publish-npm] npm pack produced no tarball in ${stageRoot}.`);
+    process.exit(1);
+  }
+  run('tar', ['-xzf', join(stageRoot, tarball), '-C', stageRoot], stageRoot);
+  const stage = join(stageRoot, 'package');
+
+  // 3. Mutate ONLY the stage copy: synthesized version, template pin,
+  //    channel release.json.
+  const stagePkg = JSON.parse(readFileSync(join(stage, 'package.json'), 'utf8'));
+  writeFileSync(join(stage, 'package.json'), JSON.stringify({ ...stagePkg, version: publishVersion }, null, 2) + '\n');
+  pinTemplateFimo(stage, publishVersion);
+  stripTemplateLockfile(stage);
+  writeReleaseJson(stage, channel);
+
+  // 4. Publish from the stage. No --provenance: sigstore provenance requires
+  //    a PUBLIC source repo, and strapi/fimo is private (npm returns 422
+  //    otherwise). Trusted Publishing (OIDC auth) works regardless of repo
+  //    visibility — it's only the attestation that's public-only.
+  const publishArgs = ['publish', '--access', 'public', '--tag', channel.distTag, '--ignore-scripts'];
+  if (dryRun) {
+    publishArgs.push('--dry-run');
+  }
+  run('npm', publishArgs, stage);
+
+  if (!dryRun && channel.distTag === 'experimental') {
+    const devStatePath = writeDevReleaseState(CLI_ROOT, {
+      version: publishVersion,
+      channel: channel.distTag,
+    });
+    console.log(`[publish-npm] wrote ${devStatePath}`);
+  }
+} finally {
+  rmSync(stageRoot, { recursive: true, force: true });
+}
+
+console.log(`[publish-npm] done${dryRun ? ' (dry-run — nothing published)' : ''}.`);

package/templates/react-router/package.json

@@ -5,7 +5,7 @@
   "type": "module",
   "scripts": {
     "dev": "react-router dev --port 5173",
-    "build": "tsc --noEmit && react-router build && fimo export-static",
+    "build": "react-router build && fimo export-static",
     "lint": "oxlint --deny-warnings",
     "typecheck": "tsc --noEmit",
     "preview": "vite preview --host 0.0.0.0 --port 4173"
@@ -13,7 +13,7 @@
   "dependencies": {
     "@base-ui/react": "^1.3.0",
     "@hookform/resolvers": "^5.2.2",
-    "@react-router/node": "^8.2.0",
+    "@react-router/node": "^7.15.1",
     "@tailwindcss/typography": "^0.5.19",
     "@tanstack/react-query": "^5.80.6",
     "class-variance-authority": "^0.7.1",
@@ -21,20 +21,20 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.7.0-experimental.3",
+    "fimo": "0.7.0-experimental.4",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",
     "motion": "^12.36.0",
     "next-themes": "^0.4.6",
     "radix-ui": "^1.4.3",
-    "react": "^19.2.7",
+    "react": "^19.2.4",
     "react-day-picker": "^9.14.0",
-    "react-dom": "^19.2.7",
+    "react-dom": "^19.2.4",
     "react-error-boundary": "^6.0.0",
     "react-hook-form": "^7.72.1",
     "react-resizable-panels": "^4.9.0",
-    "react-router": "^8.2.0",
+    "react-router": "^7.15.1",
     "recharts": "^3.8.0",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.2.0",
@@ -42,7 +42,7 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@react-router/dev": "^8.2.0",
+    "@react-router/dev": "^7.15.1",
     "@tailwindcss/vite": "^4.3.0",
     "@types/node": "^24.12.0",
     "@types/react": "^19.2.14",
@@ -52,8 +52,5 @@
     "tw-animate-css": "^1.4.0",
     "typescript": "5.9.3",
     "vite": "^8.0.13"
-  },
-  "engines": {
-    "node": ">=22.22.0"
   }
 }

package/templates/react-router/src/pages/Index.tsx

@@ -29,7 +29,7 @@ const Index = () => {
               <a href="https://fimo.ai" target="_blank" rel="noreferrer">
                 Fimo.ai
               </a>
-              <a href="https://fimo.ai/docs" target="_blank" rel="noreferrer">
+              <a href="https://docs.fimo.ai" target="_blank" rel="noreferrer">
                 Documentation
               </a>
               <a href="https://blog.fimo.ai" target="_blank" rel="noreferrer">

package/dist/runtime/content/client/createContentClient.d.ts

@@ -1,5 +0,0 @@
-import type { CollectionContentClient, ContentClientConfig } from './types.js';
-export declare function createContentClient<T extends {
-    id: string;
-}, TInput extends object>(config: ContentClientConfig): CollectionContentClient<T, TInput>;
-//# sourceMappingURL=createContentClient.d.ts.map