yuzuha 0.1.5 → 0.2.0

package/assets/canvas/OFL.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/assets/canvas/ORIGIN.md

@@ -0,0 +1,8 @@
+These unmodified font files are from Inter 4.1, distributed by the upstream
+Inter project under the SIL Open Font License 1.1.
+
+- `Inter-Regular.ttf`: Inter 4.1 Regular
+- `Inter-Bold.ttf`: Inter 4.1 Bold
+- License text: `OFL.txt`
+- Upstream release: https://github.com/rsms/inter/releases/tag/v4.1
+- License source: https://github.com/rsms/inter/blob/v4.1/LICENSE.txt

package/benchmarks/compare.mjs

@@ -2,17 +2,23 @@ export function compareReports(current, baseline) {
   for (const field of ['platform', 'arch', 'cpu']) {
     if (current[field] !== baseline[field]) throw new Error(`Baseline incompatível: ${field}.`);
   }
-  if (current.node.split('.')[0] !== baseline.node?.split('.')[0]) throw new Error('Baseline incompatível: versão principal do Node.');
+  if (current.node !== baseline.node) throw new Error('Baseline incompatível: versão exata do Node.');
+  if (current.suite !== baseline.suite) throw new Error('Baseline incompatível: suíte.');
+  if (baseline.gc !== undefined && current.gc !== baseline.gc) throw new Error('Baseline incompatível: GC explícito.');
   for (const field of ['iterations', 'samples', 'concurrency']) {
     if (current.config[field] !== baseline.config?.[field]) throw new Error(`Baseline incompatível: ${field}.`);
   }
-  for (const field of ['catalogSize', 'payloadSize', 'soakRounds']) {
+  for (const field of ['catalogSize', 'payloadSize', 'soakRounds', 'stateKeys', 'queueSize', 'pageSize', 'fanout', 'warmup']) {
     if (baseline.config?.[field] !== undefined && current.config[field] !== baseline.config[field]) throw new Error(`Baseline incompatível: ${field}.`);
   }
   if (!Array.isArray(baseline.results)) throw new Error('Baseline sem resultados.');
   return current.results.map(row => {
     const previous = baseline.results.find(item => item.name === row.name);
     if (!previous) return { name: row.name, status: 'new' };
+    for (const field of ['iterations', 'unitsPerOperation']) {
+      if (previous[field] !== undefined && row[field] !== previous[field]) throw new Error(`Baseline incompatível: ${row.name}.${field}.`);
+    }
+    if (!(row.operationsPerSecond > 0) || !Number.isFinite(row.operationsPerSecond)) throw new Error(`Medição atual inválida: ${row.name}.`);
     if (!(previous.operationsPerSecond > 0) || !Number.isFinite(previous.operationsPerSecond)) throw new Error(`Baseline inválida: ${row.name}.`);
     const throughputChangePercent = (row.operationsPerSecond / previous.operationsPerSecond - 1) * 100;
     return { name: row.name, status: 'compared', throughputChangePercent,

package/benchmarks/parser.mjs

@@ -0,0 +1,66 @@
+import assert from 'node:assert/strict';
+import { performance } from 'node:perf_hooks';
+import { cpus, platform, arch } from 'node:os';
+import { readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const modules = { current: new URL('../dist/scripting/parser.js', import.meta.url) };
+for (let index = 2; index < process.argv.length; index += 2) {
+  const key = { '--parser-module': 'current', '--baseline-module': 'baseline' }[process.argv[index]];
+  const value = process.argv[index + 1];
+  if (!key || !value || value.startsWith('--')) throw new Error('Uso: node benchmarks/parser.mjs [--parser-module caminho] [--baseline-module caminho]');
+  modules[key] = pathToFileURL(resolve(value));
+}
+const implementations = {};
+for (const [label, url] of Object.entries(modules)) implementations[label] = {
+  parse: (await import(url)).parse,
+  sourceHash: createHash('sha256').update(await readFile(url)).digest('hex'),
+};
+const iterations = 20_000, warmup = 2000, samples = 9, differentialCases = 20_000;
+const cases = {
+  plain: 'a'.repeat(8000),
+  interpolated: `prefix ${'abc '.repeat(100)}$name suffix ${'xyz '.repeat(100)}`,
+  short: '$reply[Olá $username!]',
+  dense: '$f[a;b;$g[c]]'.repeat(20),
+};
+const outcome = (parse, source) => {
+  try { return parse(source); }
+  catch (error) { return { code: error.code, offset: error.offset, message: error.message }; }
+};
+if (implementations.baseline) {
+  const alphabet = ['a', '$', '[', ']', ';', '\\', 'é', '\n', '1'];
+  for (let seed = 0; seed < differentialCases; seed++) {
+    let state = seed + 1, source = '';
+    for (let index = 0; index < 50; index++) {
+      state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
+      source += alphabet[state % alphabet.length];
+    }
+    assert.deepEqual(outcome(implementations.current.parse, source), outcome(implementations.baseline.parse, source), source);
+  }
+}
+const results = [];
+for (const [name, source] of Object.entries(cases)) {
+  if (implementations.baseline) assert.deepEqual(implementations.current.parse(source), implementations.baseline.parse(source));
+  const times = Object.fromEntries(Object.keys(implementations).map(label => [label, []]));
+  for (let sample = 0; sample < samples; sample++) {
+    const entries = Object.entries(implementations);
+    if (sample % 2) entries.reverse();
+    for (const [label, { parse }] of entries) {
+      for (let index = 0; index < warmup; index++) parse(source);
+      const start = performance.now();
+      for (let index = 0; index < iterations; index++) parse(source);
+      times[label].push(performance.now() - start);
+    }
+  }
+  for (const [implementation, samplesMs] of Object.entries(times)) {
+    const sorted = [...samplesMs].sort((a, b) => a - b);
+    results.push({ name, implementation, characters: source.length, iterations, medianMs: sorted[Math.floor(samples / 2)], samplesMs });
+  }
+}
+console.log(JSON.stringify({ suite: 'parser', date: new Date().toISOString(), node: process.versions.node,
+  platform: platform(), arch: arch(), cpu: cpus()[0]?.model, warmup, samples,
+  differentialCases: implementations.baseline ? differentialCases : 0,
+  modules: Object.fromEntries(Object.entries(implementations).map(([label, entry]) => [label, { path: modules[label].href, sourceHash: entry.sourceHash }])),
+  results }, null, 2));

package/benchmarks/performance.mjs

@@ -0,0 +1,87 @@
+import assert from 'node:assert/strict';
+import { performance } from 'node:perf_hooks';
+import { arch, cpus, platform } from 'node:os';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { compareReports } from './compare.mjs';
+
+const config = { iterations: 10_000, samples: 9, concurrency: 1, catalogSize: 1000, payloadSize: 4096, stateKeys: 2000, json: false };
+let packageRoot = fileURLToPath(new URL('../', import.meta.url)), baselinePath;
+for (let i = 2; i < process.argv.length; i++) {
+  const key = process.argv[i];
+  if (key === '--json') { config.json = true; continue; }
+  if (key === '--package-root' || key === '--baseline') {
+    const path = process.argv[++i]; if (!path || path.startsWith('--')) throw new Error(`Informe ${key} <caminho>.`);
+    if (key === '--package-root') packageRoot = resolve(path); else baselinePath = path;
+    continue;
+  }
+  const name = { '--catalog-size': 'catalogSize', '--payload-size': 'payloadSize', '--state-keys': 'stateKeys' }[key] ?? key.slice(2);
+  const max = { iterations: 1_000_000, samples: 50, catalogSize: 10_000, payloadSize: 99_000, stateKeys: 10_000 }[name];
+  const value = Number(process.argv[++i]);
+  if (!max || !Number.isSafeInteger(value) || value < 1 || value > max) throw new Error(`Opção inválida: ${key}.`);
+  config[name] = value;
+}
+const source = pathToFileURL(resolve(packageRoot, 'dist/'));
+source.pathname += source.pathname.endsWith('/') ? '' : '/';
+const { Yuzuha, CommandContext, MemoryStore } = await import(new URL('index.js', source));
+const { MockTransport, mockMessage } = await import(new URL('testing.js', source));
+const manifest = JSON.parse(await readFile(resolve(packageRoot, 'package.json'), 'utf8'));
+const results = [], bots = [];
+const percentile = (values, fraction) => [...values].sort((a, b) => a - b)[Math.ceil(values.length * fraction) - 1];
+async function measure(name, operation, iterations = config.iterations, units = 1) {
+  const run = async count => { for (let i = 0; i < count; i++) await operation(); };
+  await run(Math.min(iterations, 200)); global.gc?.();
+  const before = process.memoryUsage(), samples = [];
+  for (let sample = 0; sample < config.samples; sample++) {
+    const start = performance.now(); await run(iterations); samples.push(performance.now() - start);
+  }
+  global.gc?.(); const after = process.memoryUsage();
+  results.push({ name, iterations, unitsPerOperation: units, operations: iterations * units * config.samples, concurrency: 1,
+    medianMs: percentile(samples, 0.5), p95Ms: percentile(samples, 0.95), samplesMs: samples,
+    operationsPerSecond: iterations * units * config.samples / (samples.reduce((sum, value) => sum + value, 0) / 1000),
+    heapDeltaBytes: after.heapUsed - before.heapUsed, rssDeltaBytes: after.rss - before.rss });
+}
+function bot() {
+  const value = new Yuzuha({ transport: new MockTransport(), store: new MemoryStore(), scheduler: false, http: false }); bots.push(value); return value;
+}
+try {
+  const dispatch = bot(); dispatch.command({ name: 'bench', run() {} });
+  for (const [name, content, authorBot] of [
+    ['ordinary', 'a normal message', false], ['unknown', '!doesNotExist', false], ['bot', '!bench', true],
+  ]) {
+    const message = mockMessage(content, { authorBot });
+    await measure(`dispatch/ignored-${name}`, async () => { assert.equal(await dispatch.handle(message), 'ignored'); });
+  }
+  const payload = 'x'.repeat(config.payloadSize);
+  for (const [name, input] of [['long-input', payload], ['quoted-long-input', `"${payload}"`], ['apostrophe-long-input', `${payload}'suffix`]]) {
+    const long = `!bench ${input}`;
+    await measure(`dispatch/${name}`, async () => {
+      assert.equal(await dispatch.handle(mockMessage(long)), 'success');
+    }, Math.max(1, Math.floor(config.iterations / 10)));
+  }
+  await measure('catalog/register', async () => {
+    const registered = new Yuzuha({ transport: new MockTransport(), store: new MemoryStore(), scheduler: false, http: false });
+    try {
+      for (let i = 0; i < config.catalogSize; i++) registered.command({ name: `item${i}`, run() {} });
+      assert.equal(registered.listCommands().length, config.catalogSize);
+    } finally { await registered.destroy(); }
+  }, 1, config.catalogSize);
+  const store = new MemoryStore(), ctx = new CommandContext({ store, command: { name: 'state' },
+    message: mockMessage(''), transport: new MockTransport(), cooldown: () => 0 });
+  await ctx.data.transaction(data => {
+    for (let i = 0; i < config.stateKeys; i++) data.guild.set(`item${i}`, { count: i, tags: ['one', 'two'] });
+  });
+  const expected = { count: config.stateKeys - 1, tags: ['one', 'two'] };
+  await measure('store/read-large-state', async () => {
+    assert.deepEqual(await ctx.data.guild.get(`item${config.stateKeys - 1}`), expected);
+  }, Math.max(1, Math.floor(config.iterations / 10)));
+  const report = { suite: 'performance', version: manifest.version, date: new Date().toISOString(), node: process.versions.node,
+    platform: platform(), arch: arch(), cpu: cpus()[0]?.model, gc: typeof global.gc === 'function', config, results };
+  if (baselinePath) report.comparison = compareReports(report, JSON.parse(await readFile(baselinePath, 'utf8')));
+  console.log(config.json ? JSON.stringify(report, null, 2) : [
+    `Yuzuha ${report.version} · Node ${report.node} · ${report.platform}/${report.arch}`,
+    ...results.map(row => `${row.name}: ${row.operationsPerSecond.toFixed(0)} ops/s; mediana ${row.medianMs.toFixed(2)}ms`),
+    ...(report.comparison ?? []).map(row => `${row.name}: ${row.status === 'new' ? 'novo' : `${row.throughputChangePercent.toFixed(1)}% ante baseline`}`),
+  ].join('\n'));
+} finally { await Promise.all(bots.map(value => value.destroy())); }

package/benchmarks/rate-limits.mjs

@@ -0,0 +1,138 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { arch, cpus, platform } from 'node:os';
+import { performance } from 'node:perf_hooks';
+import { RateLimits } from '../dist/framework/rate-limits.js';
+import { YuzuhaError } from '../dist/errors.js';
+
+// Baseline: src/framework/rate-limits.ts at a227759f726420471ade044a3cf9600a6359a668, with TypeScript types removed.
+class BaselineRateLimits {
+  now;
+  seen = new Map();
+  seenKeys = [];
+  seenExpirations = [];
+  seenCursor = 0;
+  cooldowns = new Map();
+  nextSweep = 0;
+
+  constructor(now = Date.now) { this.now = now; }
+
+  sweep(time) {
+    if (time < this.nextSweep) return;
+    for (const [key, until] of this.cooldowns) if (until <= time) this.cooldowns.delete(key);
+    this.nextSweep = time + 1000;
+  }
+
+  duplicate(channelID, messageID) {
+    const time = this.now();
+    this.sweep(time);
+    const key = `${channelID.length}:${channelID}${messageID}`;
+    if ((this.seen.get(key) ?? 0) > time) return true;
+    const previous = this.seenKeys[this.seenCursor];
+    if (previous !== undefined && this.seen.get(previous) === this.seenExpirations[this.seenCursor]) this.seen.delete(previous);
+    const until = time + 60_000;
+    this.seen.set(key, until);
+    this.seenKeys[this.seenCursor] = key; this.seenExpirations[this.seenCursor] = until;
+    this.seenCursor = (this.seenCursor + 1) % 10_000;
+    return false;
+  }
+
+  cooldown(key, duration) {
+    const time = this.now();
+    this.sweep(time);
+    const remaining = (this.cooldowns.get(key) ?? 0) - time;
+    if (remaining > 0) return remaining;
+    if (this.cooldowns.size >= 100_000) throw new YuzuhaError('COOLDOWN_CAPACITY', 'Capacidade de cooldown excedida.');
+    this.cooldowns.set(key, time + duration);
+    return 0;
+  }
+}
+
+const config = { samples: 7, normalIterations: 50_000, loadedIterations: 1000, entries: 25_000,
+  warmup: 2000, normalClockStepMs: 0, loadedClockStepMs: 1000, cooldownMs: 1_000_000_000_000 };
+let json = false;
+for (let index = 2; index < process.argv.length; index++) {
+  const option = process.argv[index];
+  if (option === '--json') { json = true; continue; }
+  const name = { '--samples': 'samples', '--normal-iterations': 'normalIterations', '--loaded-iterations': 'loadedIterations', '--entries': 'entries' }[option];
+  const value = Number(process.argv[++index]);
+  const max = { samples: 50, normalIterations: 90_000, loadedIterations: 100_000, entries: 100_000 }[name];
+  if (!max || !Number.isSafeInteger(value) || value < 1 || value > max) throw new Error(`Opção inválida: ${option}.`);
+  config[name] = value;
+}
+
+const scenarios = [
+  { name: 'duplicate/same-tick', operation: 'duplicate', loaded: false },
+  { name: 'cooldown/new-same-tick', operation: 'new', loaded: false },
+  { name: 'cooldown/active-same-tick', operation: 'active', loaded: false },
+  { name: 'duplicate/loaded-clock-steps', operation: 'duplicate', loaded: true },
+  { name: 'cooldown/loaded-clock-steps', operation: 'active', loaded: true },
+];
+
+function fixture(Implementation, scenario, iterations) {
+  let now = 0;
+  const limits = new Implementation(() => now);
+  const step = scenario.loaded ? config.loadedClockStepMs : config.normalClockStepMs;
+  if (scenario.loaded) for (let index = 0; index < config.entries; index++) limits.cooldown(String(index), config.cooldownMs);
+  else if (scenario.operation === 'active') limits.cooldown('0', config.cooldownMs);
+  const outputs = new Array(iterations);
+  return {
+    run() {
+      for (let index = 0; index < iterations; index++) {
+        now += step;
+        outputs[index] = scenario.operation === 'duplicate' ? limits.duplicate('channel', String(index))
+          : limits.cooldown(scenario.operation === 'active' ? '0' : String(index), config.cooldownMs);
+      }
+    },
+    validate() {
+      for (let index = 0; index < iterations; index++) {
+        const expected = scenario.operation === 'duplicate' ? false
+          : scenario.operation === 'active' ? config.cooldownMs - step * (index + 1) : 0;
+        assert.equal(outputs[index], expected);
+      }
+      return outputs;
+    },
+  };
+}
+
+const median = values => [...values].sort((a, b) => a - b)[Math.ceil(values.length / 2) - 1];
+const summarize = (samplesMs, iterations) => ({ samplesMs, medianMs: median(samplesMs),
+  operationsPerSecond: iterations * samplesMs.length / (samplesMs.reduce((sum, value) => sum + value, 0) / 1000) });
+const implementations = [['baseline', BaselineRateLimits], ['current', RateLimits]];
+const results = [];
+for (const scenario of scenarios) {
+  const iterations = scenario.loaded ? config.loadedIterations : config.normalIterations;
+  for (const [, Implementation] of implementations) {
+    const warmup = fixture(Implementation, scenario, Math.min(config.warmup, iterations));
+    warmup.run(); warmup.validate();
+  }
+  const samples = { baseline: [], current: [] };
+  for (let sample = 0; sample < config.samples; sample++) {
+    const outputs = {};
+    for (const [name, Implementation] of sample % 2 ? [...implementations].reverse() : implementations) {
+      const trial = fixture(Implementation, scenario, iterations);
+      global.gc?.();
+      const start = performance.now();
+      trial.run();
+      samples[name].push(performance.now() - start);
+      outputs[name] = trial.validate();
+    }
+    assert.deepEqual(outputs.current, outputs.baseline);
+  }
+  const baseline = summarize(samples.baseline, iterations), current = summarize(samples.current, iterations);
+  results.push({ name: scenario.name, iterations, entries: scenario.loaded ? config.entries : scenario.operation === 'active' ? 1 : 0,
+    clockStepMs: scenario.loaded ? config.loadedClockStepMs : config.normalClockStepMs, baseline, current,
+    medianChangePercent: (current.medianMs / baseline.medianMs - 1) * 100 });
+}
+const hash = input => createHash('sha256').update(input).digest('hex');
+const report = { suite: 'rate-limits', date: new Date().toISOString(), node: process.versions.node, platform: platform(), arch: arch(),
+  cpu: cpus()[0]?.model, gc: typeof global.gc === 'function', baselineCommit: 'a227759f726420471ade044a3cf9600a6359a668',
+  sourceHashes: { baselineImplementation: hash(BaselineRateLimits.toString()), currentDist: hash(await readFile(new URL('../dist/framework/rate-limits.js', import.meta.url))),
+    benchmark: hash(await readFile(new URL(import.meta.url))) }, config,
+  scope: 'Local synthetic workloads; advancing the fake clock simulates sweep boundaries, not wall-clock throughput of a bot.', results };
+console.log(json ? JSON.stringify(report, null, 2) : [
+  `RateLimits · Node ${report.node} · ${report.cpu} · ${report.platform}/${report.arch}`,
+  report.scope,
+  ...results.map(row => `${row.name}: ${row.baseline.medianMs.toFixed(3)} -> ${row.current.medianMs.toFixed(3)} ms; ${row.iterations} operations; clock +${row.clockStepMs} ms/operation`),
+].join('\n'));

package/benchmarks/refinement.mjs

@@ -0,0 +1,99 @@
+import assert from 'node:assert/strict';
+import { performance } from 'node:perf_hooks';
+import { arch, cpus, platform } from 'node:os';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { compareReports } from './compare.mjs';
+import { createHash } from 'node:crypto';
+
+const config = { iterations: 10_000, samples: 7, warmup: 2000, queueSize: 5000, pageSize: 25, fanout: 32, concurrency: 1, json: false };
+let packageRoot = fileURLToPath(new URL('../', import.meta.url)), baselinePath;
+for (let index = 2; index < process.argv.length; index++) {
+  const key = process.argv[index];
+  if (key === '--json') { config.json = true; continue; }
+  if (key === '--package-root' || key === '--baseline') {
+    const value = process.argv[++index]; if (!value || value.startsWith('--')) throw new Error(`Informe ${key} <caminho>.`);
+    if (key === '--package-root') packageRoot = resolve(value); else baselinePath = value;
+    continue;
+  }
+  const name = { '--queue-size': 'queueSize', '--page-size': 'pageSize' }[key] ?? key.slice(2);
+  const max = { iterations: 1_000_000, samples: 50, warmup: 100_000, queueSize: 100_000, pageSize: 1000, fanout: 128 }[name];
+  const value = Number(process.argv[++index]);
+  if (!max || !Number.isSafeInteger(value) || value < 1 || value > max) throw new Error(`Opção inválida: ${key}.`);
+  config[name] = value;
+}
+if (config.pageSize > config.queueSize) throw new Error('pageSize deve caber na fila.');
+const source = pathToFileURL(resolve(packageRoot, 'dist') + '/');
+const { Yuzuha, MemoryStore } = await import(new URL('index.js', source));
+const { MusicManager, LavalinkNode } = await import(new URL('music.js', source));
+const { MockTransport, MockMusicBackend, mockMessage, mockTrack } = await import(new URL('testing.js', source));
+const { parseFlags } = await import(new URL('commands/arguments.js', source));
+const manifest = JSON.parse(await readFile(resolve(packageRoot, 'package.json'), 'utf8'));
+const sourceHashes = {};
+for (const path of ['commands/arguments.js', 'domain/track-queue.js', 'domain/music-state.js', 'services/music.js', 'services/music-player.js', 'infrastructure/lavalink/node.js', 'infrastructure/lavalink/protocol.js']) {
+  try { sourceHashes[path] = createHash('sha256').update(await readFile(new URL(path, source))).digest('hex'); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; sourceHashes[path] = null; }
+}
+const results = [];
+const percentile = (values, fraction) => [...values].sort((a, b) => a - b)[Math.ceil(values.length * fraction) - 1];
+async function measure(name, operation, iterations = config.iterations, metrics) {
+  const run = async count => { for (let index = 0; index < count; index++) await operation(); };
+  await run(Math.min(iterations, config.warmup)); global.gc?.();
+  const before = process.memoryUsage(), samples = [], initial = metrics?.();
+  for (let sample = 0; sample < config.samples; sample++) {
+    const start = performance.now(); await run(iterations); samples.push(performance.now() - start);
+  }
+  global.gc?.(); const after = process.memoryUsage(), operations = iterations * config.samples;
+  results.push({ name, iterations, operations, unitsPerOperation: 1, concurrency: 1,
+    medianMs: percentile(samples, 0.5), p95Ms: percentile(samples, 0.95), samplesMs: samples,
+    operationsPerSecond: operations / (samples.reduce((sum, value) => sum + value, 0) / 1000),
+    heapDeltaBytes: after.heapUsed - before.heapUsed, rssDeltaBytes: after.rss - before.rss,
+    ...(metrics ? { backendRequests: metrics() - initial, backendRequestsPerOperation: (metrics() - initial) / operations } : {}),
+  });
+}
+const flags = [
+  { name: 'count', type: 'integer', min: 1, max: 20 }, { name: 'verbose', type: 'boolean', aliases: ['v'] },
+  { name: 'speed', type: 'number', defaultValue: 1 }, { name: 'timeout', type: 'duration' },
+  { name: 'label', type: 'string' }, { name: 'owner', type: 'user' }, { name: 'format', defaultValue: 'opus', choices: ['opus', 'webm'] },
+];
+const tokens = ['tune', '--count', '3', '-v', '--speed=1.25', '--timeout', '2s', '--label=lofi mix', '--owner', '12345678901234567'];
+const bot = new Yuzuha({ transport: new MockTransport(), store: new MemoryStore(), scheduler: false, http: false });
+const manager = new MusicManager({ nodes: [new MockMusicBackend()], queueLimit: config.queueSize });
+let backendRequests = 0;
+const node = new LavalinkNode({ url: 'http://localhost:2333', password: 'offline', userID: '123', cache: false, reconnect: false,
+  maxPendingRequests: config.fanout, socketFactory() { throw new Error('Benchmark offline não conecta ao gateway.'); },
+  fetch: async () => {
+    backendRequests++; await new Promise(resolve => setImmediate(resolve));
+    return Response.json({ loadType: 'track', data: mockTrack('result') });
+  },
+});
+try {
+  await measure('arguments/typed-flags', () => {
+    const result = parseFlags(flags, tokens); assert.equal(result.flags.get('count'), 3); assert.equal(result.flags.get('format'), 'opus');
+  });
+  bot.command({ name: 'bench', flags, run(ctx) { assert.equal(ctx.flags.get('count'), 3); assert.equal(ctx.flags.get('label'), 'lofi mix'); } });
+  await measure('dispatch/typed-flags', async () => {
+    assert.equal(await bot.handle(mockMessage('!bench tune --count 3 -v --speed=1.25 --timeout 2s --label="lofi mix" --owner 12345678901234567')), 'success');
+  });
+  const player = manager.createPlayer('100'); player.enqueue(Array.from({ length: config.queueSize }, (_, index) => mockTrack(String(index))));
+  const start = Math.min(Math.floor(config.queueSize / 2), config.queueSize - config.pageSize);
+  await measure('music/queue-page', () => {
+    const page = typeof player.queuePage === 'function' ? player.queuePage(start, config.pageSize) : player.queue.slice(start, start + config.pageSize);
+    assert.equal(page.length, config.pageSize); assert.equal(page[0].encoded, String(start));
+  }, Math.max(1, Math.floor(config.iterations / 100)));
+  let batch = 0;
+  await measure('music/signaled-search-fanout', async () => {
+    const identifier = `scsearch:batch${++batch}`;
+    const results = await Promise.all(Array.from({ length: config.fanout }, () => node.loadTracks(identifier, new AbortController().signal)));
+    assert.equal(results.length, config.fanout); assert.equal(results[0].loadType, 'track');
+  }, Math.max(1, Math.floor(config.iterations / 100)), () => backendRequests);
+  const report = { suite: 'refinement', version: manifest.version, date: new Date().toISOString(), node: process.versions.node,
+    platform: platform(), arch: arch(), cpu: cpus()[0]?.model, gc: typeof global.gc === 'function', sourceHashes, config, results };
+  if (baselinePath) report.comparison = compareReports(report, JSON.parse(await readFile(baselinePath, 'utf8')));
+  console.log(config.json ? JSON.stringify(report, null, 2) : [
+    `Yuzuha ${report.version} · Node ${report.node} · ${report.platform}/${report.arch}`,
+    ...results.map(row => `${row.name}: ${row.operationsPerSecond.toFixed(0)} ops/s; mediana ${row.medianMs.toFixed(2)}ms${row.backendRequests === undefined ? '' : `; ${row.backendRequestsPerOperation} requisições simuladas/lote`}`),
+    ...(report.comparison ?? []).map(row => `${row.name}: ${row.status === 'new' ? 'novo' : `${row.throughputChangePercent.toFixed(1)}% ante baseline`}`),
+  ].join('\n'));
+} finally { await bot.destroy(); await manager.close(); await node.close(); }