fimo 0.7.0-experimental.3 → 0.7.0-staging.1

package/scripts/lib/channels.mjs

@@ -0,0 +1,70 @@
+// Single source of truth for fimo release channels.
+//
+// channel → { source, apiUrl, webUrl, distTag, prerelease }
+//
+// Read by the npm publish path (scripts/publish-npm.mjs) and the CI
+// release workflow. Defined ONCE so the npm and (legacy) R2 paths can
+// never drift on "what does staging mean" — the bug class behind a
+// published build accidentally pointing at the wrong API.
+//
+// Hard rule (D5): a published package bakes ONLY staging or prod. Never a
+// tunnel or localhost — that would leak a private URL to the public
+// registry. Tunnels/localhost are runtime FIMO_API_URL overrides, never
+// baked. `ALLOWED_API_URLS` enforces this at publish time.
+
+// Staging lives on the .team domain; production is fimo.ai.
+export const STAGING_API_URL = 'https://api.staging.fimo.team';
+export const STAGING_WEB_URL = 'https://staging.fimo.team';
+export const PROD_API_URL = 'https://api.fimo.ai';
+export const PROD_WEB_URL = 'https://fimo.ai';
+
+/**
+ * @typedef {Object} Channel
+ * @property {'npm'} source        - marks the published build's origin
+ * @property {string} apiUrl       - cloud API base baked into release.json
+ * @property {string} webUrl       - web URL baked into release.json
+ * @property {string} distTag      - npm dist-tag to publish under
+ * @property {boolean} prerelease  - true → synthesize a disposable X.Y.Z-<tag>.N version
+ */
+
+/** @type {Record<string, Channel>} */
+export const CHANNELS = {
+  experimental: {
+    source: 'npm',
+    apiUrl: STAGING_API_URL,
+    webUrl: STAGING_WEB_URL,
+    distTag: 'experimental',
+    prerelease: true,
+  },
+  staging: {
+    source: 'npm',
+    apiUrl: STAGING_API_URL,
+    webUrl: STAGING_WEB_URL,
+    distTag: 'staging',
+    prerelease: true,
+  },
+  latest: {
+    source: 'npm',
+    apiUrl: PROD_API_URL,
+    webUrl: PROD_WEB_URL,
+    distTag: 'latest',
+    prerelease: false,
+  },
+};
+
+// A published package may bake ONLY these api URLs. Everything else
+// (localhost, tunnels) is refused at publish time.
+export const ALLOWED_API_URLS = new Set([STAGING_API_URL, PROD_API_URL]);
+
+/**
+ * Resolve a channel by name, throwing on an unknown name.
+ * @param {string} name
+ * @returns {Channel}
+ */
+export function resolveChannel(name) {
+  const channel = CHANNELS[name];
+  if (!channel) {
+    throw new Error(`Unknown channel "${name}". Valid channels: ${Object.keys(CHANNELS).join(', ')}.`);
+  }
+  return channel;
+}

package/scripts/lib/dev-release-state.mjs

@@ -0,0 +1,44 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+
+/**
+ * Record the latest locally-published experimental CLI version for this
+ * checkout. `fimo deploy` uses this to swap a project-local `file:` dependency
+ * to an immutable npm version before pushing to a remote sandbox.
+ *
+ * @param {string} cliRoot - apps/cli root
+ * @param {{ version: string, channel: string }} release
+ * @returns {string} the file written
+ */
+export function writeDevReleaseState(cliRoot, release) {
+  const repoRoot = resolve(cliRoot, '..', '..');
+  const dir = resolve(repoRoot, '.fimo');
+  mkdirSync(dir, { recursive: true });
+
+  const payload = {
+    version: release.version,
+    channel: release.channel,
+    packageRoot: relative(repoRoot, cliRoot),
+    gitSha: readGitSha(repoRoot),
+    publishedAt: new Date().toISOString(),
+  };
+
+  const file = resolve(dir, 'dev.json');
+  writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
+  return file;
+}
+
+function readGitSha(repoRoot) {
+  const result = spawnSync('git', ['rev-parse', 'HEAD'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+  });
+  if (result.status === 0) {
+    const sha = result.stdout.trim();
+    if (sha.length > 0) {
+      return sha;
+    }
+  }
+  return null;
+}

package/scripts/lib/dev-release-state.test.ts

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { writeDevReleaseState } from './dev-release-state.mjs';
+
+const tmpRoots: string[] = [];
+
+afterEach(() => {
+  for (const root of tmpRoots.splice(0)) {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+describe('writeDevReleaseState', () => {
+  it('writes repo-root .fimo/dev.json for the checkout', () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'fimo-dev-state-'));
+    tmpRoots.push(root);
+    const cliRoot = path.join(root, 'apps', 'cli');
+    fs.mkdirSync(cliRoot, { recursive: true });
+
+    const file = writeDevReleaseState(cliRoot, {
+      version: '0.2.3-experimental.42',
+      channel: 'experimental',
+    });
+
+    expect(file).toBe(path.join(root, '.fimo', 'dev.json'));
+    expect(JSON.parse(fs.readFileSync(file, 'utf8'))).toMatchObject({
+      version: '0.2.3-experimental.42',
+      channel: 'experimental',
+      packageRoot: 'apps/cli',
+    });
+  });
+});

package/scripts/lib/postinstall-onboarding.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'vitest';
+
+import { isGlobalInstall, parseYesNo, shouldPromptForGlobalSkills } from './postinstall-onboarding.mjs';
+
+describe('isGlobalInstall', () => {
+  it('detects npm global installs', () => {
+    expect(isGlobalInstall({ npm_config_global: 'true' })).toBe(true);
+  });
+
+  it('detects package-manager location=global installs', () => {
+    expect(isGlobalInstall({ npm_config_location: 'global' })).toBe(true);
+  });
+
+  it('ignores local installs', () => {
+    expect(isGlobalInstall({})).toBe(false);
+  });
+});
+
+describe('shouldPromptForGlobalSkills', () => {
+  it('prompts only for interactive global installs', () => {
+    expect(
+      shouldPromptForGlobalSkills({
+        env: { npm_config_global: 'true' },
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+      })
+    ).toEqual({ ok: true });
+  });
+
+  it('skips CI and non-interactive installs', () => {
+    expect(
+      shouldPromptForGlobalSkills({
+        env: { npm_config_global: 'true', CI: '1' },
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+      })
+    ).toMatchObject({ ok: false, reason: 'ci' });
+    expect(
+      shouldPromptForGlobalSkills({
+        env: { npm_config_global: 'true' },
+        stdinIsTTY: false,
+        stdoutIsTTY: true,
+      })
+    ).toMatchObject({ ok: false, reason: 'non-interactive' });
+  });
+
+  it('honors the explicit skip env var', () => {
+    expect(
+      shouldPromptForGlobalSkills({
+        env: { npm_config_global: 'true', FIMO_SKIP_POSTINSTALL_PROMPT: '1' },
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+      })
+    ).toMatchObject({ ok: false, reason: 'disabled' });
+  });
+
+  it('skips package-manager assume-yes installs', () => {
+    expect(
+      shouldPromptForGlobalSkills({
+        env: { npm_config_global: 'true', npm_config_yes: 'true' },
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+      })
+    ).toMatchObject({ ok: false, reason: 'assume-yes-install' });
+    expect(
+      shouldPromptForGlobalSkills({
+        env: { npm_config_global: 'true', npm_config_force: 'true' },
+        stdinIsTTY: true,
+        stdoutIsTTY: true,
+      })
+    ).toMatchObject({ ok: false, reason: 'assume-yes-install' });
+  });
+});
+
+describe('parseYesNo', () => {
+  it('parses yes, no, and empty defaults', () => {
+    expect(parseYesNo('y')).toBe(true);
+    expect(parseYesNo('no')).toBe(false);
+    expect(parseYesNo('', true)).toBe(true);
+    expect(parseYesNo('', false)).toBe(false);
+  });
+});

package/scripts/lib/release-core.mjs

@@ -0,0 +1,225 @@
+// Shared release-core: the channel-aware release.json bake.
+//
+// This is the single place that stamps which environment a published
+// build talks to. Both the npm publish path and any future CI job call
+// it, so the "which URL goes in which build" decision can't drift.
+//
+// `release.json` is a publish artifact: it is gitignored (apps/cli/.gitignore)
+// and only exists transiently while packing. The CLI reads it at runtime as
+// `FIMO_API_URL env || baked release.json || localhost` — so the bake only
+// governs a bare `npm i -g fimo` with no env set. The sandbox always
+// overrides it via the injected `.env`.
+
+import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+import { ALLOWED_API_URLS } from './channels.mjs';
+
+const TEMPLATE_PKG_REL = 'templates/react-router/package.json';
+const TEMPLATE_LOCK_REL = 'templates/react-router/pnpm-lock.yaml';
+
+/**
+ * Write a `release.json` for a published (`source: 'npm'`) build using the
+ * channel's baked URLs. Refuses any apiUrl not on the allowlist so a
+ * tunnel/localhost can never reach the public registry (D5).
+ *
+ * @param {string} cliRoot - apps/cli root
+ * @param {import('./channels.mjs').Channel} channel
+ * @returns {string} the path written
+ */
+export function writeReleaseJson(cliRoot, channel) {
+  if (!ALLOWED_API_URLS.has(channel.apiUrl)) {
+    throw new Error(
+      `Refusing to bake non-allowlisted apiUrl "${channel.apiUrl}" into a published package. ` +
+        `Published channels may bake only staging or prod (D5).`
+    );
+  }
+  const payload = {
+    source: channel.source,
+    apiUrl: channel.apiUrl,
+    webUrl: channel.webUrl,
+  };
+  const file = resolve(cliRoot, 'release.json');
+  writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
+  return file;
+}
+
+/**
+ * Pin the bundled template's `fimo` dependency to an exact version at pack
+ * time, so a project scaffolded from `fimo@X` depends on exactly `fimo@X`
+ * (immutable, reproducible — no mutable URL, no caret drift). The committed
+ * template keeps a dev-friendly value; this overwrites it only for the
+ * tarball and the returned function restores it afterwards.
+ *
+ * @param {string} cliRoot
+ * @param {string} version - exact version to pin (e.g. "0.3.0" or "0.3.0-experimental.4")
+ * @returns {() => void} restore - rewrites the original file contents back
+ */
+export function pinTemplateFimo(cliRoot, version) {
+  const file = resolve(cliRoot, TEMPLATE_PKG_REL);
+  if (!existsSync(file)) {
+    return () => {};
+  }
+  const original = readFileSync(file, 'utf8');
+  const pkg = JSON.parse(original);
+  let changed = false;
+  for (const field of ['dependencies', 'devDependencies']) {
+    if (pkg[field] && typeof pkg[field].fimo === 'string' && pkg[field].fimo !== version) {
+      pkg[field].fimo = version;
+      changed = true;
+    }
+  }
+  if (changed) {
+    writeFileSync(file, JSON.stringify(pkg, null, 2) + '\n');
+  }
+  return () => writeFileSync(file, original);
+}
+
+/**
+ * Remove the template's pnpm-lock.yaml from the tarball at pack time.
+ *
+ * We can't ship a correct lockfile: it would have to pin the exact version
+ * we're about to publish, which isn't on the registry yet (chicken-and-egg).
+ * A stale lockfile pinning a different spec than package.json breaks frozen
+ * installs (the 2026-06-11 outage class). With an exact, immutable version in
+ * package.json, `fimo create` + a fresh `pnpm install` resolves
+ * deterministically — so shipping no lockfile is the correct choice.
+ * `scaffold.ts` already deletes the lockfile whenever it rewrites the dep, so
+ * this only matters for the exact-npm-match path, but it's always safe.
+ *
+ * @param {string} cliRoot
+ * @returns {() => void} restore - rewrites the original lockfile back, if any
+ */
+export function stripTemplateLockfile(cliRoot) {
+  const file = resolve(cliRoot, TEMPLATE_LOCK_REL);
+  if (!existsSync(file)) {
+    return () => {};
+  }
+  const original = readFileSync(file, 'utf8');
+  rmSync(file, { force: true });
+  return () => writeFileSync(file, original);
+}
+
+/**
+ * Parse `npm view <name> versions --json` output into a flat list of version
+ * strings, tolerating every shape npm has shipped: an array of strings
+ * (npm <= 11), a bare string when exactly one version is published
+ * (npm <= 11), and the npm 12 wrapper — "npm view --json now always returns
+ * an array", one entry per matched version, i.e. `[[...versions]]` for a bare
+ * package name. Returns null when nothing version-shaped survives (error
+ * envelopes, empty output), so callers fall back to the run-number/timestamp
+ * counter instead of trusting garbage.
+ *
+ * @param {string} stdout - raw stdout of `npm view <name> versions --json`
+ * @returns {string[] | null}
+ */
+export function parsePublishedVersions(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+  const versions = (Array.isArray(parsed) ? parsed : [parsed]).flat().filter((version) => typeof version === 'string');
+  return versions.length > 0 ? versions : null;
+}
+
+/**
+ * Next per-version prerelease counter: one past the highest already-published
+ * `<base>-<distTag>.<n>` on npm. Counting from what's actually published
+ * (instead of resetting blindly to 1) keeps the counter collision-proof even
+ * when the projected base flaps back to a value that already has prereleases —
+ * npm versions are immutable, so a blind reset would make the publish fail.
+ *
+ * @param {readonly string[]} existingVersions - all published versions of the package
+ * @param {string} base - X.Y.Z base (no prerelease suffix)
+ * @param {string} distTag
+ * @returns {number}
+ */
+export function nextPrereleaseCounter(existingVersions, base, distTag) {
+  const prefix = `${base}-${distTag}.`;
+  let max = 0;
+  for (const version of existingVersions) {
+    if (!version.startsWith(prefix)) {
+      continue;
+    }
+    const n = Number(version.slice(prefix.length));
+    if (Number.isInteger(n) && n > max) {
+      max = n;
+    }
+  }
+  return max + 1;
+}
+
+/**
+ * Compute the version to publish for a channel.
+ * - Stable (`latest`) publishes the exact package.json version.
+ * - Prerelease channels synthesize a disposable `X.Y.Z-<distTag>.<n>`.
+ *   `n` counts per base version (`0.3.5-staging.1`, `.2`, …) when the
+ *   published versions could be fetched from npm; otherwise it falls back
+ *   to the CI run number, then a timestamp.
+ *
+ * @param {string} baseVersion - package.json version
+ * @param {import('./channels.mjs').Channel} channel
+ * @param {{ runId?: string, existingVersions?: readonly string[] }} [opts]
+ * @returns {string}
+ */
+export function computePublishVersion(baseVersion, channel, opts = {}) {
+  if (!channel.prerelease) {
+    return baseVersion;
+  }
+  // Strip any existing prerelease suffix from the base so we don't stack them.
+  const base = baseVersion.split('-')[0];
+  const n = opts.existingVersions
+    ? String(nextPrereleaseCounter(opts.existingVersions, base, channel.distTag))
+    : (opts.runId ?? String(Date.now()));
+  return `${base}-${channel.distTag}.${n}`;
+}
+
+const BUMP_RANK = { patch: 1, minor: 2, major: 3 };
+
+/**
+ * Peek at pending changeset files and compute the version the next
+ * `changeset version` run will produce for `fimo`. Prerelease channels use
+ * this as their base so a staging build advertises the version prod will
+ * actually ship (`0.3.4-staging.26` while 0.3.4 is pending) instead of the
+ * already-released base. No pending changesets (or no .changeset dir) →
+ * base unchanged.
+ *
+ * @param {string} baseVersion - package.json version
+ * @param {string} changesetDir - absolute path to the repo's .changeset dir
+ * @returns {string}
+ */
+export function nextVersionFromChangesets(baseVersion, changesetDir) {
+  let entries;
+  try {
+    entries = readdirSync(changesetDir);
+  } catch {
+    return baseVersion;
+  }
+
+  let maxBump = null;
+  for (const name of entries) {
+    if (!name.endsWith('.md') || name === 'README.md') {
+      continue;
+    }
+    const text = readFileSync(join(changesetDir, name), 'utf8');
+    const frontmatter = text.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? '';
+    const bump = frontmatter.match(/['"]?fimo['"]?\s*:\s*(patch|minor|major)/)?.[1];
+    if (bump && (!maxBump || BUMP_RANK[bump] > BUMP_RANK[maxBump])) {
+      maxBump = bump;
+    }
+  }
+
+  if (!maxBump) {
+    return baseVersion;
+  }
+  const [major, minor, patch] = baseVersion.split('-')[0].split('.').map(Number);
+  if (maxBump === 'major') {
+    return `${major + 1}.0.0`;
+  }
+  if (maxBump === 'minor') {
+    return `${major}.${minor + 1}.0`;
+  }
+  return `${major}.${minor}.${patch + 1}`;
+}

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');
+  });
+});