hobots 1.5.1 → 1.7.0

package/docs/{manager.md → tasks.md}

@@ -1,6 +1,6 @@
-# Manager
+# Tasks (execução sob demanda)
 
-Capability de **execução remota sob demanda**, habilitada com `manager: true` (ou opções) no `init()` único. O agente faz polling no app, executa os handlers registrados quando aparece trabalho e reporta status e logs incrementais. Usa o mesmo Client Secret, o mesmo `debug` e o `instanceId` como identidade — nenhum handler global extra é instalado.
+Capability de **execução remota sob demanda**, habilitada com `tasks: true` (ou opções) no `init()` único. O agente faz polling no app, executa os handlers registrados quando aparece trabalho e reporta status e logs incrementais — é o que alimenta o módulo **Solicitações** do app. Usa o mesmo Client Secret, o mesmo `debug` e o `instanceId` como identidade — nenhum handler global extra é instalado.
 
 O vocabulário desta página ([run](./concepts.md#run), [claim](./concepts.md#claim), [drain mode](./concepts.md#drain-mode), [ctx.tx](./concepts.md#transaction-de-run-ctxtx)) está explicado em [Conceitos](./concepts.md).
 
@@ -12,7 +12,7 @@ import * as Hobots from 'hobots';
 Hobots.init({
   clientSecret: 'hb_<64 hex>',
   instanceId: 'vm-cliente-01',
-  manager: true, // ou { pollIntervalMs, concurrency, taskTimeoutMs, logFlushIntervalMs }
+  tasks: true, // ou { pollIntervalMs, concurrency, taskTimeoutMs, logFlushIntervalMs }
 });
 
 Hobots.register('processar-nfe', async (params, ctx) => {
@@ -28,26 +28,26 @@ process.on('SIGINT', () => {
 });
 ```
 
-- `init({ manager })` — cria o agente. Chamar `init()` de novo para o agente anterior e o substitui (os handlers registrados são preservados). Se havia runs em execução, elas são interrompidas **sem espera** e reportadas como `AgentTerminated` na hora — `init()` não é um jeito gracioso de reconfigurar um agente ocupado; para isso use `stop()` antes.
-- `register(task, handler)` — `task` é o `task_slug` configurado no formulário do app. Registre **antes** de `start()`. Pode ser chamado antes do `init()`; se o `init()` não habilitou o Manager, o SDK avisa no console.
-- `start()` — começa o polling. Lança se o `init()` não configurou `manager` ou se nenhuma task foi registrada.
-- `stop(timeoutMs?)` — para **só o Manager**: encerra o polling e aguarda as runs ativas ([default](./api-reference.md#tempos-e-intervalos)); a telemetria continua. Retorna `false` se estourou o timeout.
+- `init({ tasks })` — cria o agente. Chamar `init()` de novo para o agente anterior e o substitui (os handlers registrados são preservados). Se havia runs em execução, elas são interrompidas **sem espera** e reportadas como `AgentTerminated` na hora — `init()` não é um jeito gracioso de reconfigurar um agente ocupado; para isso use `stop()` antes.
+- `register(task, handler)` — `task` é o `task_slug` configurado no formulário do app (**Configurações → Formulários**). Registre **antes** de `start()`. Pode ser chamado antes do `init()`; se o `init()` não habilitou as tasks, o SDK avisa no console.
+- `start()` — começa o polling. Lança se o `init()` não configurou `tasks` ou se nenhuma task foi registrada.
+- `stop(timeoutMs?)` — para **só o polling de tasks**: encerra o polling e aguarda as runs ativas ([default](./api-reference.md#tempos-e-intervalos)); a telemetria continua. Retorna `false` se estourou o timeout.
 - `close(timeoutMs?)` — encerra **tudo**: agente (aguardando runs em voo) → heartbeat → flush final.
 
-O `instanceId` (obrigatório) é a identidade do agente no painel — o poll o envia como `agent.instance_id`, a **mesma identidade** do heartbeat do Monitor. Com o `init()` único, os dois canais convergem em **um agente** automaticamente.
+O `instanceId` (obrigatório) é a identidade do agente no painel — o poll o envia como `agent.instance_id`, a **mesma identidade** do heartbeat de telemetria. Com o `init()` único, os dois canais convergem em **um agente** no módulo Agentes automaticamente. Com `tasks: true`, o heartbeat é **opcional**: o próprio poll já marca a presença do agente; o heartbeat continua essencial para agentes só de telemetria.
 
 > **Atenção:** ao contrário da telemetria, `start()` **segura o processo vivo** aguardando trabalho até `stop()`/`close()` — o agente é a razão do processo existir.
 
 ## O handler e o `RunContext`
 
 ```ts
-type ManagerTaskHandler<P = Record<string, unknown>> =
+type TaskHandler<P = Record<string, unknown>> =
   (params: P, ctx: RunContext) => void | Promise<void>;
 
 interface RunContext {
   runId: string;
   task: string;
-  log(level: 'debug' | 'info' | 'warning' | 'error', message: string): void;
+  log: RunLogger; // ctx.log.debug/info/warn/error/success(message)
   tx: Transaction;
   signal: AbortSignal;
   throwIfCanceled(): void;
@@ -56,7 +56,7 @@ interface RunContext {
 ```
 
 - **`params`** — os dados do formulário configurado no app (o JSON validado).
-- **`ctx.log.<level>(message)`** — logs enviados **incrementalmente** ao app (PATCHes com throttle), visíveis na run em tempo quase real. Cada linha também é **impressa no terminal local** como `[hobots:<task>] INFO mensagem`, colorida por nível — útil para acompanhar o robô rodando na VM. A cor é desligada automaticamente fora de um TTY e quando a env `NO_COLOR` está definida; o eco local é independente do envio ao servidor.
+- **`ctx.log.<level>(message)`** — níveis `debug`, `info`, `warn`, `error` e `success`; logs enviados **incrementalmente** ao app (PATCHes com throttle), visíveis na solicitação em tempo quase real. Cada linha também é **impressa no terminal local** como `[hobots:<task>] INFO mensagem`, colorida por nível — útil para acompanhar o robô rodando na VM. A cor é desligada automaticamente fora de um TTY e quando a env `NO_COLOR` está definida; o eco local é independente do envio ao servidor.
 - **`ctx.tx`** — a [transaction de performance](./concepts.md#transaction-de-run-ctxtx) desta run, já correlacionada e finalizada pelo SDK. Use `ctx.tx.startChild()` para medir as etapas (veja abaixo).
 - **`ctx.signal`** — `AbortSignal` que dispara quando a run é **cancelada no app**, em **timeout** ou no **shutdown**. Cancelamento é cooperativo (veja abaixo).
 - **`ctx.throwIfCanceled()`** — lança `RunCanceled` se o `signal` já disparou. O ponto de parada de 1 linha para chamar entre as etapas do trabalho.
@@ -66,7 +66,7 @@ interface RunContext {
 
 Você pode tipar os params: `Hobots.register<{ lote: number }>(...)`.
 
-> **Dados sensíveis:** o que você escreve em `ctx.log()` e as mensagens/stack de erros lançados **são enviados ao servidor** e ficam visíveis na execução no app. Não inclua senhas, tokens, documentos, dados pessoais ou qualquer informação sensível em logs e mensagens de erro.
+> **Dados sensíveis:** o que você escreve em `ctx.log` e as mensagens/stack de erros lançados **são enviados ao servidor** e ficam visíveis na execução no app. Não inclua senhas, tokens, documentos, dados pessoais ou qualquer informação sensível em logs e mensagens de erro.
 
 ## Performance da run (`ctx.tx`)
 
@@ -89,14 +89,14 @@ Hobots.register('processar-nfe', async (params, ctx) => {
 
 Cada `startChild` vira uma barra no waterfall da aba de performance daquela execução no app — é como você responde "onde foram os 4 minutos". Sem nenhum span, a transaction ainda mede o tempo total da run; o waterfall só fica com uma barra.
 
-- **Não chame `Hobots.startTransaction()` dentro de um handler.** Você criaria uma segunda transaction, sem correlação com a run, e ela não apareceria na execução.
-- `ctx.tx` **não respeita o `tracesSampleRate`** — toda run gera uma transaction. A amostragem vale só para as transactions que você abre com `startTransaction()`.
+- **`startTransaction()` dentro do handler devolve a própria `ctx.tx`.** Cada execução tem exatamente **uma** transaction: se o seu código (ou uma lib sua já instrumentada) chamar `Hobots.startTransaction()` dentro de um handler, o SDK detecta o contexto da run e retorna a transaction dela em vez de criar uma segunda — os spans caem no mesmo waterfall. Fora de um handler, `startTransaction()` cria uma transaction nova, sem `run_id`.
+- `ctx.tx` **não respeita o `tracesSampleRate`** — toda run gera uma transaction. A amostragem vale só para as transactions abertas com `startTransaction()` fora de uma run.
 - Span que você esquecer aberto é fechado no `finish()` da transaction, então o dado não se perde.
 - Marque etapas com ressalva usando `span.setStatus('warning')` (ex.: retry que deu certo, resultado parcial): elas aparecem em âmbar no waterfall, distintas de sucesso e de falha (`'error'`).
 
 ## Cancelamento cooperativo
 
-Uma run cancelada no app **não mata** o seu handler — o SDK não interrompe código em execução. Ele apenas dispara `ctx.signal`. Enquanto o handler roda, o SDK mantém um **heartbeat de cancelamento** (a cada `cancelCheckIntervalMs`, veja [Tempos e intervalos](./api-reference.md#tempos-e-intervalos)): a run cancelada no app é detectada em segundos, mesmo que o handler nunca chame `ctx.log()`. Chame **`ctx.throwIfCanceled()`** em loops longos e pontos de parada (e troque esperas por `ctx.sleep()`):
+Uma run cancelada no app **não mata** o seu handler — o SDK não interrompe código em execução. Ele apenas dispara `ctx.signal`. Enquanto o handler roda, o SDK mantém um **heartbeat de cancelamento** (a cada `cancelCheckIntervalMs`, veja [Tempos e intervalos](./api-reference.md#tempos-e-intervalos)): a run cancelada no app é detectada em segundos, mesmo que o handler nunca chame `ctx.log`. Chame **`ctx.throwIfCanceled()`** em loops longos e pontos de parada (e troque esperas por `ctx.sleep()`):
 
 ```js
 Hobots.register('processar-nfe', async (params, ctx) => {
@@ -113,7 +113,7 @@ Quando o cancelamento veio do app, a run já está `cancelada` no servidor — o
 
 Se o processo do agente **morre no meio de uma run**, a solicitação vira **falha** no app com erro `AgentTerminated` ("execução encerrada inesperadamente") — sem re-execução automática. Dois caminhos garantem isso:
 
-- **Morte capturável** (SIGINT/SIGTERM sem handler próprio do programa, erro não tratado): o SDK reporta a falha na hora (~2s, um PATCH best-effort com timeout curto) e então deixa o processo morrer com a semântica default do sinal. Os handlers são instalados no `start()` e **nunca interferem** quando o programa tem handler próprio para o sinal (o shutdown gracioso via `close()` continua sendo o caminho normal). Desative com `manager: { installExitHandlers: false }`.
+- **Morte capturável** (SIGINT/SIGTERM sem handler próprio do programa, erro não tratado): o SDK reporta a falha na hora (~2s, um PATCH best-effort com timeout curto) e então deixa o processo morrer com a semântica default do sinal. Os handlers são instalados no `start()` e **nunca interferem** quando o programa tem handler próprio para o sinal (o shutdown gracioso via `close()` continua sendo o caminho normal). Desative com `tasks: { installExitHandlers: false }`.
 - **Morte dura** (kill -9, queda de energia, rede fora): nada roda no cliente. O heartbeat de cancelamento é também o **sinal de vida da run** — o servidor marca a run como falha ao notar silêncio prolongado (o [sweep](./api-reference.md#tempos-e-intervalos) server-side).
 
 `close(timeoutMs)` que estoura o timeout com runs ainda em execução também reporta essas runs como `AgentTerminated` — o processo vai morrer em seguida e o app não deve mostrar a run como "executando" para sempre.
@@ -130,8 +130,8 @@ Se o agente morrer logo **após capturar** uma run (antes de reportar `running`)
 
 `taskTimeoutMs` é um timeout **client-side**. No estouro o SDK **não mata** o handler — ele dispara `ctx.signal`, libera o slot de concorrência e reporta a run como falha (`TaskTimeout`). O handler pode continuar rodando em background; respeite o `signal` para parar de verdade. Sem `taskTimeoutMs`, o backstop é o servidor.
 
-Todas as opções em [Referência de API → ManagerOptions](./api-reference.md#manageroptions).
+Todas as opções em [Referência de API → TasksOptions](./api-reference.md#tasksoptions).
 
 ## Como o claim funciona (resumo)
 
-O SDK é um cliente HTTP: ele faz `POST /v1/manager/poll` e o **servidor** reivindica as runs pendentes de forma atômica com `FOR UPDATE SKIP LOCKED` — dois agentes nunca pegam a mesma run. Conceito em [Claim](./concepts.md#claim), detalhes em [Protocolo & transporte](./protocol.md).
+O SDK é um cliente HTTP: ele faz `POST /v1/tasks/poll` e o **servidor** reivindica as runs pendentes de forma atômica com `FOR UPDATE SKIP LOCKED` — dois agentes nunca pegam a mesma run. Conceito em [Claim](./concepts.md#claim), detalhes em [Protocolo & transporte](./protocol.md).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hobots",
-  "version": "1.5.1",
-  "description": "SDK JavaScript da Hobots — captura de erros, transactions, check-ins de cron e heartbeats (Monitor) e execução remota de tarefas sob demanda (Manager) para RPAs e integrações. Um único import e um único init().",
+  "version": "1.7.0",
+  "description": "SDK JavaScript da Hobots — telemetria (erros, transactions, check-ins de cron e heartbeats) e execução remota de tarefas sob demanda (tasks) para RPAs e integrações. Um único import e um único init().",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",
@@ -25,17 +25,13 @@
       "types": "./dist/protocol.d.ts",
       "import": "./dist/protocol.js",
       "require": "./dist/protocol.cjs"
-    },
-    "./manager/protocol": {
-      "types": "./dist/manager/protocol.d.ts",
-      "import": "./dist/manager/protocol.js",
-      "require": "./dist/manager/protocol.cjs"
     }
   },
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
     "lint": "eslint . --max-warnings 0",
+    "test": "node --test \"test/**/*.test.mjs\"",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {

package/dist/manager/protocol.cjs

@@ -1,19 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/manager/protocol.ts
-var protocol_exports = {};
-module.exports = __toCommonJS(protocol_exports);
-//# sourceMappingURL=protocol.cjs.map

package/dist/manager/protocol.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/manager/protocol.ts"],"sourcesContent":["/**\n * Tipos do protocolo do Hobots Manager (agente SDK ↔ servidor).\n *\n * Este arquivo é a fonte de verdade do wire format e não pode importar nada:\n * o app valida os payloads com zod e trava o drift via `satisfies z.ZodType<...>`\n * contra estes tipos (reexportados por `hobots/protocol`; `hobots/manager/protocol` é alias transitório).\n */\n\n/** Ciclo de vida completo de uma run no servidor. */\nexport type ManagerRunStatus = 'pending' | 'claimed' | 'running' | 'succeeded' | 'failed' | 'canceled';\n\n/** Subconjunto que o agente pode enviar no PATCH. */\nexport type ManagerRunUpdateStatus = 'running' | 'succeeded' | 'failed';\n\nexport type RunLogLevel = 'debug' | 'info' | 'warning' | 'error' | 'success';\n\nexport interface RunLogEntry {\n  /** ISO 8601 — relógio do agente, apenas para exibição */\n  ts: string;\n  level: RunLogLevel;\n  message: string;\n}\n\nexport interface ManagerAgentInfo {\n  /** Identidade canônica do agente — correlaciona com o heartbeat do Monitor */\n  instance_id: string;\n  name?: string;\n  /** Versão do SDK */\n  version?: string;\n  /** Hostname da máquina */\n  host?: string;\n  /** Tasks registradas no agente */\n  tasks?: string[];\n}\n\n/** POST /v1/manager/poll */\nexport interface ManagerPollRequest {\n  agent?: ManagerAgentInfo;\n  /** Quantas runs reivindicar de uma vez (1..5). Default: 1 */\n  max?: number;\n  /** Só entrega runs destas tasks (nomes registrados no agente) */\n  tasks?: string[];\n}\n\nexport interface ManagerRunDescriptor {\n  id: string;\n  task: string;\n  params: Record<string, unknown>;\n  form: { id: string; name: string } | null;\n  /** Origem da run: 'hobots' | 'link' | 'schedule' (informativo) */\n  source: string;\n  /** ISO 8601 (relógio do servidor) */\n  created_at: string;\n}\n\nexport interface ManagerPollResponse {\n  runs: ManagerRunDescriptor[];\n}\n\nexport interface ManagerRunError {\n  /** ex.: nome da classe do erro */\n  type?: string;\n  message: string;\n  stack?: string;\n}\n\n/** PATCH /v1/manager/runs/{id} — 'running' pode repetir com logs incrementais */\nexport interface ManagerRunUpdateRequest {\n  status: ManagerRunUpdateStatus;\n  /** Apenas com status 'failed' */\n  error?: ManagerRunError;\n  /** Delta desde o último envio — o servidor concatena */\n  logs?: RunLogEntry[];\n}\n\nexport interface ManagerRunUpdateResponse {\n  ok: true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/manager/protocol.d.cts

@@ -1,72 +0,0 @@
-/**
- * Tipos do protocolo do Hobots Manager (agente SDK ↔ servidor).
- *
- * Este arquivo é a fonte de verdade do wire format e não pode importar nada:
- * o app valida os payloads com zod e trava o drift via `satisfies z.ZodType<...>`
- * contra estes tipos (reexportados por `hobots/protocol`; `hobots/manager/protocol` é alias transitório).
- */
-/** Ciclo de vida completo de uma run no servidor. */
-type ManagerRunStatus = 'pending' | 'claimed' | 'running' | 'succeeded' | 'failed' | 'canceled';
-/** Subconjunto que o agente pode enviar no PATCH. */
-type ManagerRunUpdateStatus = 'running' | 'succeeded' | 'failed';
-type RunLogLevel = 'debug' | 'info' | 'warning' | 'error' | 'success';
-interface RunLogEntry {
-    /** ISO 8601 — relógio do agente, apenas para exibição */
-    ts: string;
-    level: RunLogLevel;
-    message: string;
-}
-interface ManagerAgentInfo {
-    /** Identidade canônica do agente — correlaciona com o heartbeat do Monitor */
-    instance_id: string;
-    name?: string;
-    /** Versão do SDK */
-    version?: string;
-    /** Hostname da máquina */
-    host?: string;
-    /** Tasks registradas no agente */
-    tasks?: string[];
-}
-/** POST /v1/manager/poll */
-interface ManagerPollRequest {
-    agent?: ManagerAgentInfo;
-    /** Quantas runs reivindicar de uma vez (1..5). Default: 1 */
-    max?: number;
-    /** Só entrega runs destas tasks (nomes registrados no agente) */
-    tasks?: string[];
-}
-interface ManagerRunDescriptor {
-    id: string;
-    task: string;
-    params: Record<string, unknown>;
-    form: {
-        id: string;
-        name: string;
-    } | null;
-    /** Origem da run: 'hobots' | 'link' | 'schedule' (informativo) */
-    source: string;
-    /** ISO 8601 (relógio do servidor) */
-    created_at: string;
-}
-interface ManagerPollResponse {
-    runs: ManagerRunDescriptor[];
-}
-interface ManagerRunError {
-    /** ex.: nome da classe do erro */
-    type?: string;
-    message: string;
-    stack?: string;
-}
-/** PATCH /v1/manager/runs/{id} — 'running' pode repetir com logs incrementais */
-interface ManagerRunUpdateRequest {
-    status: ManagerRunUpdateStatus;
-    /** Apenas com status 'failed' */
-    error?: ManagerRunError;
-    /** Delta desde o último envio — o servidor concatena */
-    logs?: RunLogEntry[];
-}
-interface ManagerRunUpdateResponse {
-    ok: true;
-}
-
-export type { ManagerAgentInfo, ManagerPollRequest, ManagerPollResponse, ManagerRunDescriptor, ManagerRunError, ManagerRunStatus, ManagerRunUpdateRequest, ManagerRunUpdateResponse, ManagerRunUpdateStatus, RunLogEntry, RunLogLevel };

package/dist/manager/protocol.d.ts

@@ -1,72 +0,0 @@
-/**
- * Tipos do protocolo do Hobots Manager (agente SDK ↔ servidor).
- *
- * Este arquivo é a fonte de verdade do wire format e não pode importar nada:
- * o app valida os payloads com zod e trava o drift via `satisfies z.ZodType<...>`
- * contra estes tipos (reexportados por `hobots/protocol`; `hobots/manager/protocol` é alias transitório).
- */
-/** Ciclo de vida completo de uma run no servidor. */
-type ManagerRunStatus = 'pending' | 'claimed' | 'running' | 'succeeded' | 'failed' | 'canceled';
-/** Subconjunto que o agente pode enviar no PATCH. */
-type ManagerRunUpdateStatus = 'running' | 'succeeded' | 'failed';
-type RunLogLevel = 'debug' | 'info' | 'warning' | 'error' | 'success';
-interface RunLogEntry {
-    /** ISO 8601 — relógio do agente, apenas para exibição */
-    ts: string;
-    level: RunLogLevel;
-    message: string;
-}
-interface ManagerAgentInfo {
-    /** Identidade canônica do agente — correlaciona com o heartbeat do Monitor */
-    instance_id: string;
-    name?: string;
-    /** Versão do SDK */
-    version?: string;
-    /** Hostname da máquina */
-    host?: string;
-    /** Tasks registradas no agente */
-    tasks?: string[];
-}
-/** POST /v1/manager/poll */
-interface ManagerPollRequest {
-    agent?: ManagerAgentInfo;
-    /** Quantas runs reivindicar de uma vez (1..5). Default: 1 */
-    max?: number;
-    /** Só entrega runs destas tasks (nomes registrados no agente) */
-    tasks?: string[];
-}
-interface ManagerRunDescriptor {
-    id: string;
-    task: string;
-    params: Record<string, unknown>;
-    form: {
-        id: string;
-        name: string;
-    } | null;
-    /** Origem da run: 'hobots' | 'link' | 'schedule' (informativo) */
-    source: string;
-    /** ISO 8601 (relógio do servidor) */
-    created_at: string;
-}
-interface ManagerPollResponse {
-    runs: ManagerRunDescriptor[];
-}
-interface ManagerRunError {
-    /** ex.: nome da classe do erro */
-    type?: string;
-    message: string;
-    stack?: string;
-}
-/** PATCH /v1/manager/runs/{id} — 'running' pode repetir com logs incrementais */
-interface ManagerRunUpdateRequest {
-    status: ManagerRunUpdateStatus;
-    /** Apenas com status 'failed' */
-    error?: ManagerRunError;
-    /** Delta desde o último envio — o servidor concatena */
-    logs?: RunLogEntry[];
-}
-interface ManagerRunUpdateResponse {
-    ok: true;
-}
-
-export type { ManagerAgentInfo, ManagerPollRequest, ManagerPollResponse, ManagerRunDescriptor, ManagerRunError, ManagerRunStatus, ManagerRunUpdateRequest, ManagerRunUpdateResponse, ManagerRunUpdateStatus, RunLogEntry, RunLogLevel };

package/dist/manager/protocol.js

@@ -1 +0,0 @@
-//# sourceMappingURL=protocol.js.map

package/dist/manager/protocol.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}