primocode 10.19.0 → 11.0.0

package/lib/tool/reparar-entrada.js

@@ -0,0 +1,66 @@
+/**
+ * reparar-entrada.js — conserta o argumento da ferramenta que o modelo grátis mandou com o TIPO errado.
+ *
+ * Modelo pequeno manda {"limit":"20"}, {"replace_all":"false"}, {"edits":"[...]"} ou {"offset":null}.
+ * Sem reparo, a ferramenta recusa e o modelo gasta uma volta inteira só pra trocar aspas.
+ * Ideia e regras portadas do ToolInputRepairPlugin do OpenCode (MIT, ver LICENSES/opencode-MIT.txt);
+ * código reescrito em JS, sobre um schema simples ({ campo: 'number'|'boolean'|'array'|'object'|'string' }).
+ *
+ * Regra de ouro (a mesma do casar.js): só repara quando o schema deixa claro. Na dúvida, devolve como veio.
+ *
+ *   reparar(args, schema)  → novo objeto (puro, não muda o original)
+ *   SCHEMAS                → tipos dos campos das ferramentas do agente
+ */
+
+'use strict';
+
+const SCHEMAS = {
+    read_file: { offset: 'number', limit: 'number' },
+    edit_file: { replace_all: 'boolean' },
+    multi_edit: { edits: 'array' },
+    write_todos: { todos: 'array' },
+    glob: { limit: 'number' },
+    run_shell: { timeout_ms: 'number', em_segundo_plano: 'boolean' },
+    perguntar: { opcoes: 'array', texto_livre: 'boolean' },
+    buscar_web: { limite: 'number' },
+    ler_url: { max_chars: 'number', desde: 'number' },
+    grep: { limit: 'number', context: 'number', ignore_case: 'boolean' },
+};
+
+function jsonOuNada(s) {
+    try { return { ok: true, v: JSON.parse(s) }; } catch { return { ok: false }; }
+}
+
+function converter(valor, tipo) {
+    if (valor === null) return undefined; // opcional com null → como se não tivesse vindo
+    if (typeof valor === 'string') {
+        const t = valor.trim();
+        if (tipo === 'number' && /^-?\d+(\.\d+)?$/.test(t)) return Number(t);
+        if (tipo === 'boolean' && /^(true|false)$/i.test(t)) return t.toLowerCase() === 'true';
+        if (tipo === 'array' || tipo === 'object') {
+            const j = jsonOuNada(t);
+            if (j.ok && (tipo === 'array' ? Array.isArray(j.v) : j.v && typeof j.v === 'object' && !Array.isArray(j.v))) return j.v;
+        }
+    }
+    return valor;
+}
+
+function reparar(args, schema) {
+    let a = args;
+    if (typeof a === 'string') { // objeto inteiro virou texto: '{"limit":"20"}'
+        const j = jsonOuNada(a);
+        if (!j.ok || !j.v || typeof j.v !== 'object' || Array.isArray(j.v)) return args;
+        a = j.v;
+    }
+    if (!a || typeof a !== 'object' || !schema) return a;
+    const out = { ...a };
+    for (const [campo, tipo] of Object.entries(schema)) {
+        if (!(campo in out)) continue;
+        const v = converter(out[campo], tipo);
+        if (v === undefined) delete out[campo];
+        else out[campo] = v;
+    }
+    return out;
+}
+
+module.exports = { reparar, SCHEMAS };

package/lib/tool/web.js

@@ -0,0 +1,102 @@
+/**
+ * web.js — buscar_web e ler_url (ideia: websearch/webfetch do OpenCode, MIT).
+ *
+ * Reaproveita lib/referencia.js: pegar() (UA de navegador, redirect, prazo, bloqueio de SSRF)
+ * e buscar() (Bing/Yahoo/DDG/Wikipedia, sem chave). Aqui só ficam a forma da resposta (curta,
+ * pra modelo pequeno) e o html → markdown simples, com teto de tamanho.
+ *
+ * Backend de busca é plugável: registrarBackend(nome, async (consulta, limite) => [{titulo,url,trecho?}]).
+ * Os registrados rodam ANTES dos padrões (ex.: um SearxNG próprio, uma API paga por config).
+ */
+'use strict';
+
+const referencia = require('../referencia');
+
+const TETO_PADRAO = 12000;
+const TETO_MAXIMO = 40000;
+const backends = [];
+
+function registrarBackend(nome, fn) {
+    const i = backends.findIndex((b) => b.nome === nome);
+    if (i >= 0) backends.splice(i, 1);
+    backends.unshift({ nome, fn });
+}
+function limparBackends() { backends.length = 0; }
+
+/** DuckDuckGo HTML com trecho (snippet). Grátis, sem chave. */
+async function ddgHtml(consulta, limite, pegar = referencia.pegar) {
+    const html = await pegar(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(consulta)}`, { timeout: 8000 });
+    if (!html) return [];
+    const out = [];
+    const re = /<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>([\s\S]*?)(?=<a[^>]+class="[^"]*result__a|$)/gi;
+    let m;
+    while ((m = re.exec(html)) && out.length < limite) {
+        let href = m[1];
+        const emb = href.match(/[?&]uddg=([^&]+)/);
+        if (emb) href = decodeURIComponent(emb[1]);
+        if (!/^https?:\/\//i.test(href)) continue;
+        const sn = m[3].match(/class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/(?:a|td|div)>/i);
+        out.push({ titulo: referencia.textoDe(m[2]).slice(0, 140), url: href, trecho: sn ? referencia.textoDe(sn[1]).slice(0, 240) : '' });
+    }
+    return out;
+}
+
+async function buscarWeb({ consulta, query, limite } = {}, { pegar } = {}) {
+    const q = String(consulta || query || '').trim();
+    if (!q) return { ok: false, error: 'faltou "consulta": o que buscar na web.' };
+    const n = Math.max(1, Math.min(10, Number(limite) || 6));
+    const lista = [...backends, { nome: 'duckduckgo', fn: (c, l) => ddgHtml(c, l, pegar) },
+        { nome: 'multi', fn: (c, l) => referencia.buscar(c, l) }];
+    for (const b of lista) {
+        let r = [];
+        try { r = await b.fn(q, n); } catch { r = []; }
+        if (r && r.length) {
+            return { ok: true, consulta: q, fonte: b.nome, resultados: r.slice(0, n),
+                proximoPasso: 'Escolha 1 ou 2 links e chame ler_url com a url pra ler a página. Não responda só com os títulos.' };
+        }
+    }
+    return { ok: false, error: `nada encontrado para "${q}" (sem internet ou buscadores bloqueados).`,
+        comoResolver: 'tente outras palavras, mais curtas, ou use ler_url se já souber o link.' };
+}
+
+/** HTML → markdown simples: título, cabeçalhos, links, listas, código. */
+function htmlParaMarkdown(html) {
+    let h = String(html || '');
+    const titulo = (h.match(/<title[^>]*>([\s\S]*?)<\/title>/i) || [])[1] || '';
+    h = h.replace(/<(script|style|noscript|svg|nav|footer|header|aside|form)[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<!--[\s\S]*?-->/g, ' ');
+    const principal = h.match(/<(main|article)[^>]*>([\s\S]*?)<\/\1>/i);
+    if (principal) h = principal[2];
+    h = h.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_, n, t) => `\n\n${'#'.repeat(Number(n))} ${t.replace(/<[^>]+>/g, '')}\n\n`)
+        .replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, (_, t) => `\n\n\`\`\`\n${t.replace(/<[^>]+>/g, '')}\n\`\`\`\n\n`)
+        .replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, t) => `\`${t.replace(/<[^>]+>/g, '')}\``)
+        .replace(/<a[^>]+href="([^"#][^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_, u, t) => {
+            const tx = t.replace(/<[^>]+>/g, '').trim();
+            return tx && /^https?:/i.test(u) ? `[${tx}](${u})` : tx;
+        })
+        .replace(/<li[^>]*>/gi, '\n- ')
+        .replace(/<(br|\/p|\/div|\/tr|\/ul|\/ol)\b[^>]*>/gi, '\n')
+        .replace(/<[^>]+>/g, '');
+    h = h.replace(/&nbsp;/g, ' ').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'").replace(/&amp;/g, '&')
+        .replace(/[ \t]+/g, ' ').replace(/ *\n */g, '\n').replace(/\n{3,}/g, '\n\n').trim();
+    return { titulo: referencia.textoDe(titulo).slice(0, 160), markdown: h };
+}
+
+async function lerUrl({ url, max_chars, desde } = {}, { pegar = referencia.pegar } = {}) {
+    const u = String(url || '').trim();
+    if (!/^https?:\/\//i.test(u)) return { ok: false, error: 'faltou "url" completa, começando com http:// ou https://.' };
+    const teto = Math.max(500, Math.min(TETO_MAXIMO, Number(max_chars) || TETO_PADRAO));
+    const bruto = await pegar(u, { timeout: 12000 });
+    if (!bruto) return { ok: false, error: `não consegui abrir ${u} (fora do ar, bloqueado ou endereço interno).` };
+    const texto = String(bruto);
+    const ehHtml = /<(html|body|p|div|h1)\b/i.test(texto.slice(0, 4000));
+    const { titulo, markdown } = ehHtml ? htmlParaMarkdown(texto) : { titulo: '', markdown: texto.trim() };
+    const ini = Math.max(0, Number(desde) || 0);
+    const fatia = markdown.slice(ini, ini + teto);
+    const sobrou = markdown.length - (ini + fatia.length);
+    return { ok: true, url: u, titulo, texto: fatia, caracteres: fatia.length,
+        ...(sobrou > 0 ? { cortado: sobrou, dica: `Faltam ${sobrou} caracteres. Chame ler_url de novo com desde:${ini + fatia.length} se precisar.` } : {}) };
+}
+
+module.exports = { buscarWeb, lerUrl, htmlParaMarkdown, registrarBackend, limparBackends, ddgHtml };

package/lib/tools.js

@@ -618,7 +618,12 @@ function getTodos() { return TODOS; }
  */
 async function execute(name, args, ctx) {
     try {
-        return await despachar(name, args, ctx);
+        const r = await despachar(name, require('./tool/reparar-entrada').reparar(args, require('./tool/reparar-entrada').SCHEMAS[name]), ctx);
+        // Escreveu arquivo? O verificador mais barato da linguagem roda e o erro volta junto (lib/tool/diagnostico.js).
+        if (name === 'write_file' || name === 'edit_file' || name === 'multi_edit') {
+            return require('./tool/diagnostico').anexar(r, (ctx && ctx.projectDir) || process.cwd());
+        }
+        return r;
     } catch (e) {
         // Erro que sabe o que EXISTE leva a informação junto — mesma ideia do
         // `trechosParecidos` do edit_file. Erro seco faz o modelo chutar de novo.
@@ -720,6 +725,10 @@ async function despachar(name, args, ctx) {
                     aoFalar: (t) => { try { process.stdout.write(require('./ui.js').c.muted(`  ⎿ ${t}`) + '\n'); } catch { /* sem terminal */ } } });
                 if (kit) return kit;
                 // Dentro da cerca (lib/sandbox.js); desligada ou sem mecanismo cai no exec de sempre.
+                // em_segundo_plano: devolve um id na hora; a saída se lê com background_output e o fim chega como aviso.
+                if (args.em_segundo_plano === true || args.em_segundo_plano === 'true') {
+                    return require('./fundo').iniciar(args.command, { projectDir, env: ambienteLimpo(process.env, permitidasNoShell()) });
+                }
                 const prazo = Number(args.timeout_ms) || 60000;
                 const r = await sandbox.executar(args.command, { projectDir, timeout: prazo,
                     env: ambienteLimpo(process.env, permitidasNoShell()) });
@@ -759,10 +768,20 @@ async function despachar(name, args, ctx) {
                 return multiEdit(args, projectDir);
             case 'write_todos':
                 return writeTodos(args);
+            case 'agentes_buscar':
+                return require('./agentes').ferramentaBuscar(args || {});
+            case 'capacidade_buscar':
+                return require('./agentes').ferramentaCapacidade(args || {});
 
             // Pesquisa de referência: abre documentação e exemplos sobre o
             // pedido e devolve o TEXTO para o modelo aprender antes de
             // escrever. Aparece no terminal, com as fontes — nada oculto.
+            case 'perguntar':
+                return require('./tool/perguntar').perguntar(args, ctx);
+            case 'buscar_web':
+                return require('./tool/web').buscarWeb(args);
+            case 'ler_url':
+                return require('./tool/web').lerUrl(args);
             case 'pesquisar_referencia': {
                 const r = await referencia.pesquisar({
                     consulta: args.consulta || args.query || '',

package/lib/ui.js

@@ -547,7 +547,7 @@ const ROTULOS = {
         read_file:'Read', write_file:'Write', edit_file:'Edit', multi_edit:'MultiEdit',
         list_dir:'List', glob:'Glob', grep:'Grep', run_shell:'Bash',
         run_in_new_terminal:'Terminal', run_background:'Fundo', background_output:'Fundo·log', stop_background:'Fundo·stop', open_in_browser:'Open', spawn_agent:'Agent',
-        write_todos:'Plano', finish:'Finish', pesquisar_referencia:'Pesquisa',
+        write_todos:'Plano', perguntar:'Pergunta', finish:'Finish', pesquisar_referencia:'Pesquisa',
         browser_open:'Browser', browser_click:'Browser·click', browser_type:'Browser·type',
         browser_key:'Browser·key', browser_read:'Browser·read', browser_screenshot:'Browser·shot',
         browser_scroll:'Browser·scroll', browser_wait:'Browser·wait', browser_eval:'Browser·eval',

package/materiais/saas-linear/base.ts

@@ -0,0 +1,84 @@
+// Base do kit saas-linear (v2, "SaaS · produto em ação"): cores, fontes, curvas e medidas.
+// Os elementos importam só este arquivo, 'react' e 'remotion'. Nada de fora da pasta do kit.
+import {continueRender, delayRender} from 'remotion';
+import serifaUrl from './fontes/newsreader-400.woff2';
+import ui400Url from './fontes/inter-400.woff2';
+import ui600Url from './fontes/inter-600.woff2';
+
+// ---------- tela do vídeo ----------
+export const LARGURA = 1080, ALTURA = 1920, FPS = 30;
+export const SEGURA = {topo: 168, base: 1330, lado: 80};
+
+// ---------- a tela do produto (o "monitor") ----------
+// Todo elemento de cena se posiciona em coordenadas da TELA (0..1500 x 0..940), não do vídeo.
+// No plano fechado (zoom 1) a tela aparece 1:1, centrada em x 540 / y 860 do vídeo:
+// o que fica entre x 290 e 1210 da tela cabe na área útil do vídeo (80..1000).
+export const TELA = {w: 1500, h: 940, cx: 750, cy: 470, util: {x0: 290, x1: 1210}};
+export const CENTRO_VIDEO = {x: 540, y: 860};
+
+// ---------- cor ----------
+export const COR = {
+  parede: '#3B1E19',      // fundo atrás do monitor (sala quente, pouca luz)
+  parede2: '#6A3426',     // a luz quente que bate na parede
+  mesa: '#1E1512',
+  moldura: '#141312',     // borda do monitor
+  tela: '#F4F1EA',        // creme da interface
+  cartao: '#FFFFFF',
+  linha: '#E7E2D8',
+  tinta: '#29261F',       // texto principal
+  mute: '#8C877C',        // texto de apoio, placeholder
+  acento: '#D46F4D',      // a marca (flor coral): só na marca e no botão de enviar
+  azul: '#3D7BF0',        // toggle ligado, "Conectado"
+  agenda: ['#E7655A', '#F0A63A', '#3FA86C', '#4B83E6', '#E08A6C'],
+};
+export const SOMBRA = {
+  cartao: '0 2px 4px rgba(41,38,31,0.05), 0 18px 40px rgba(41,38,31,0.10)',
+  menu: '0 4px 10px rgba(41,38,31,0.08), 0 30px 70px rgba(41,38,31,0.16)',
+};
+
+// ---------- fonte ----------
+export const FONTE_S = '"SL Newsreader", Georgia, serif';
+export const FONTE_U = '"SL Inter", system-ui, sans-serif';
+const LISTA = [
+  {fam: 'SL Newsreader', url: serifaUrl, peso: '400', estilo: 'normal'},
+  {fam: 'SL Inter', url: ui400Url, peso: '400', estilo: 'normal'},
+  {fam: 'SL Inter', url: ui600Url, peso: '600', estilo: 'normal'},
+];
+if (typeof document !== 'undefined' && !(globalThis as Record<string, unknown>).__kit_SL2) {
+  (globalThis as Record<string, unknown>).__kit_SL2 = true;
+  for (const f of LISTA) {
+    const h = delayRender('saas-linear: ' + f.fam + ' ' + f.peso);
+    new FontFace(f.fam, `url(${f.url}) format('woff2')`, {weight: f.peso, style: f.estilo}).load()
+      .then((ff) => {document.fonts.add(ff); continueRender(h);})
+      .catch(() => continueRender(h));
+  }
+}
+
+// ---------- tempo e curva ----------
+export const c01 = (t: number) => Math.max(0, Math.min(1, t));
+/** progresso 0..1 de f entre a e b */
+export const seg = (f: number, a: number, b: number) => c01((f - a) / (b - a));
+/** curva padrão do kit: cubic-bezier(.22,1,.36,1) aproximada (saída rápida, pouso longo e preciso) */
+export const e4 = (t: number) => 1 - Math.pow(1 - c01(t), 4);
+/** entra e sai suave (câmera, cursor) */
+export const e3 = (t: number) => {const x = c01(t); return x * x * (3 - 2 * x);};
+/** overshoot pequeno, ~4% (cartões, blocos da agenda) */
+export const eb = (t: number) => {const x = c01(t) - 1, c = 1.4; return 1 + (c + 1) * x * x * x + c * x * x;};
+export const lerp = (a: number, b: number, t: number) => a + (b - a) * t;
+/** uma batida da trilha (100 bpm) em quadros */
+export const BATIDA = 18;
+
+// ---------- texto ----------
+let canvas: HTMLCanvasElement | null = null;
+export const larguraTexto = (texto: string, tamanho: number, familia = FONTE_S, peso = 400): number => {
+  if (typeof document === 'undefined') return texto.length * tamanho * 0.5;
+  canvas = canvas || document.createElement('canvas');
+  const ctx = canvas.getContext('2d'); if (!ctx) return texto.length * tamanho * 0.5;
+  ctx.font = `${peso} ${tamanho}px ${familia}`;
+  return ctx.measureText(texto).width;
+};
+/** o maior tamanho até `tamanho` em que o texto cabe em `largura`. Nunca palavra cortada. */
+export const caber = (texto: string, tamanho: number, largura: number, familia = FONTE_S, peso = 400) => {
+  const w = larguraTexto(texto, tamanho, familia, peso);
+  return w > largura ? Math.floor(tamanho * (largura / w)) : tamanho;
+};

package/materiais/saas-linear/camera/Camera.tsx

@@ -0,0 +1,38 @@
+// Camera: leva o monitor do plano aberto (z 0: o aparelho inteiro, em 3/4) ao plano fechado (z 1: a tela
+// ocupa o vídeo). Entre as chaves a câmera anda devagar e com precisão; por baixo, uma deriva que não para.
+// z acima de 1 aproxima de verdade (1.3 = tela 30% maior), pra mirar num pedaço da interface.
+// `chaves`: [{em, z, x?, y?}] em quadros absolutos; x/y deslocam o foco em px da tela (positivo = olhar pra direita/baixo).
+import React from 'react';
+import {AbsoluteFill, useCurrentFrame} from 'remotion';
+import {CENTRO_VIDEO, e3, lerp} from '../base';
+
+export type ChaveCamera = {em: number; z: number; x?: number; y?: number};
+export type CameraProps = {chaves?: ChaveCamera[]; children: React.ReactNode};
+
+export const posCamera = (f: number, chaves: ChaveCamera[]) => {
+  const ks = chaves.length ? [...chaves].sort((a, b) => a.em - b.em) : [{em: 0, z: 1}];
+  let z = ks[0].z, x = ks[0].x ?? 0, y = ks[0].y ?? 0;
+  for (let i = 0; i < ks.length - 1; i++) {
+    const a = ks[i], b = ks[i + 1];
+    if (f >= a.em) {
+      const t = e3((f - a.em) / Math.max(1, b.em - a.em));
+      z = lerp(a.z, b.z, t); x = lerp(a.x ?? 0, b.x ?? 0, t); y = lerp(a.y ?? 0, b.y ?? 0, t);
+    }
+  }
+  const zc = Math.min(1, z);
+  const escala = (z <= 1 ? lerp(0.58, 1, z) : z) * (1 + 0.035 * Math.sin(f / 110) + 0.00018 * f);
+  const rotY = lerp(-20, -9, zc) + 1.6 * Math.sin(f / 95);
+  const rotX = lerp(6, 2.5, zc) + 0.8 * Math.cos(f / 120);
+  const dx = Math.sin(f / 80) * 10 - x * escala, dy = Math.cos(f / 100) * 8 - y * escala + lerp(-40, 0, zc);
+  return {escala, rotY, rotX, dx, dy};
+};
+
+export const Camera: React.FC<CameraProps> = ({chaves = [], children}) => {
+  const c = posCamera(useCurrentFrame(), chaves);
+  return <AbsoluteFill style={{perspective: 2600, perspectiveOrigin: `${CENTRO_VIDEO.x}px ${CENTRO_VIDEO.y}px`}}>
+    <AbsoluteFill style={{transformOrigin: `${CENTRO_VIDEO.x}px ${CENTRO_VIDEO.y}px`,
+      transform: `translate(${c.dx}px, ${c.dy}px) rotateX(${c.rotX}deg) rotateY(${c.rotY}deg) scale(${c.escala})`}}>
+      {children}
+    </AbsoluteFill>
+  </AbsoluteFill>;
+};

package/materiais/saas-linear/fontes/OFL-Inter.txt

@@ -0,0 +1,93 @@
+Copyright 2020 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:
+https://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 & 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/materiais/saas-linear/fontes/OFL-Newsreader.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The Newsreader Project Authors (https://github.com/productiontype/Newsreader)
+
+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:
+https://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 & 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/materiais/saas-linear/formas/Agenda.tsx

@@ -0,0 +1,46 @@
+// Agenda: um painel de semana que se enche sozinho. Cabeçalho, dias, linhas de hora; os blocos coloridos
+// crescem da esquerda (overshoot pequeno) a cada `intervalo` quadros. `marcarEm` põe o check verde no bloco `marcar`.
+// Bloco: {dia (0..), hora (0.. a partir de `horaInicial`), dur (em horas), texto, cor?}.
+import React from 'react';
+import {useCurrentFrame} from 'remotion';
+import {COR, FONTE_U, SOMBRA, TELA, e4, eb, seg} from '../base';
+
+export type Bloco = {dia: number; hora: number; dur?: number; texto: string; cor?: string};
+export type AgendaProps = {
+  titulo: string; subtitulo?: string; dias: string[]; horaInicial?: number; horas?: number; blocos: Bloco[];
+  x?: number; y?: number; largura?: number; altura?: number; inicio?: number; intervalo?: number; marcar?: number; marcarEm?: number;
+};
+
+export const Agenda: React.FC<AgendaProps> = ({titulo, subtitulo, dias, horaInicial = 8, horas = 7, blocos, x = TELA.cx, y = 130, largura = 940, altura = 700, inicio = 0, intervalo = 3, marcar, marcarEm}) => {
+  const f = useCurrentFrame();
+  const p = e4(seg(f, inicio, inicio + 16));
+  const topo = 128, colH = 78, col = (largura - colH - 30) / dias.length, lin = (altura - topo - 24) / horas;
+  return <div style={{position: 'absolute', left: x - largura / 2, top: y, width: largura, height: altura, background: COR.cartao, borderRadius: 24,
+    boxShadow: SOMBRA.menu, border: `1.5px solid ${COR.linha}`, fontFamily: FONTE_U, opacity: p, transform: `translateY(${(1 - p) * 36}px) scale(${0.97 + 0.03 * p})`, overflow: 'hidden'}}>
+    <div style={{position: 'absolute', left: 30, top: 26, display: 'flex', alignItems: 'baseline', gap: 16}}>
+      <span style={{fontSize: 28, fontWeight: 600, color: COR.tinta}}>{titulo}</span>
+      {subtitulo && <span style={{fontSize: 20, color: COR.mute}}>{subtitulo}</span>}
+    </div>
+    {dias.map((d, i) => <div key={i} style={{position: 'absolute', top: 80, left: colH + i * col, width: col, textAlign: 'center', fontSize: 19, color: COR.mute,
+      opacity: seg(f, inicio + 4 + i, inicio + 10 + i)}}>{d}</div>)}
+    {Array.from({length: horas}).map((_, h) => <div key={h} style={{position: 'absolute', left: 0, right: 0, top: topo + h * lin}}>
+      <div style={{position: 'absolute', left: 22, top: -10, fontSize: 16, color: '#B4AEA2'}}>{String(horaInicial + h).padStart(2, '0')}:00</div>
+      <div style={{position: 'absolute', left: colH, right: 30, height: 1.5, background: '#F0ECE4', transform: `scaleX(${e4(seg(f, inicio + 2 + h, inicio + 16 + h))})`, transformOrigin: 'left'}} />
+    </div>)}
+    {blocos.map((b, i) => {
+      const t0 = inicio + 8 + i * intervalo;
+      const q = eb(seg(f, t0, t0 + 12));
+      const cor = b.cor ?? COR.agenda[i % COR.agenda.length];
+      const ok = marcar === i && marcarEm !== undefined ? eb(seg(f, marcarEm, marcarEm + 10)) : 0;
+      return <div key={i} style={{position: 'absolute', left: colH + b.dia * col + 6, top: topo + b.hora * lin + 5, width: col - 12, height: (b.dur ?? 1) * lin - 10,
+        background: cor, borderRadius: 10, opacity: seg(f, t0, t0 + 4), transform: `scaleX(${Math.max(0, q)})`, transformOrigin: 'left center',
+        boxShadow: `0 6px 14px color-mix(in srgb, ${cor} 35%, transparent)`, padding: '8px 12px', color: '#fff', fontSize: 17, fontWeight: 600, overflow: 'visible', whiteSpace: 'nowrap'}}>
+        <span style={{opacity: seg(f, t0 + 6, t0 + 12)}}>{b.texto}</span>
+        {ok > 0 && <div style={{position: 'absolute', right: -12, top: -12, width: 32, height: 32, borderRadius: 16, background: '#2E9E5B', border: '3px solid #fff',
+          transform: `scale(${ok})`, display: 'flex', alignItems: 'center', justifyContent: 'center'}}>
+          <svg width="16" height="16" viewBox="0 0 24 24"><path d="M5 12.5l4.5 4.5L19 7.5" stroke="#fff" strokeWidth="3.4" fill="none" strokeLinecap="round" strokeLinejoin="round" /></svg>
+        </div>}
+      </div>;
+    })}
+  </div>;
+};

package/materiais/saas-linear/formas/CaixaPrompt.tsx

@@ -0,0 +1,41 @@
+// CaixaPrompt: a caixa de pedido do produto. Branca, cantos 28 px, sombra macia. Placeholder cinza, botão "+"
+// embaixo à esquerda (afunda no quadro `apertarMais`), botão de enviar coral à direita, atalhos em pílula embaixo.
+// `digitar` + `digitarEm`: o texto entra letra a letra (1,4 quadro por letra) e troca o placeholder.
+import React from 'react';
+import {useCurrentFrame} from 'remotion';
+import {COR, FONTE_U, SOMBRA, TELA, e4, eb, seg} from '../base';
+
+export type CaixaPromptProps = {
+  placeholder: string; digitar?: string; digitarEm?: number; atalhos?: string[];
+  x?: number; y?: number; largura?: number; inicio?: number; apertarMais?: number;
+};
+
+export const CaixaPrompt: React.FC<CaixaPromptProps> = ({placeholder, digitar, digitarEm = 0, atalhos = [], x = TELA.cx, y = 470, largura = 880, inicio = 0, apertarMais}) => {
+  const f = useCurrentFrame();
+  const p = e4(seg(f, inicio, inicio + 18));
+  const n = digitar ? Math.floor(Math.max(0, f - digitarEm) / 1.4) : 0;
+  const texto = digitar && n > 0 ? digitar.slice(0, n) : '';
+  const aperto = apertarMais !== undefined ? 1 - 0.12 * Math.sin(Math.PI * seg(f, apertarMais, apertarMais + 8)) : 1;
+  const realce = apertarMais !== undefined ? seg(f, apertarMais, apertarMais + 4) : 0;
+  return <div style={{position: 'absolute', left: x - largura / 2, top: y, width: largura, opacity: p, transform: `translateY(${(1 - p) * 30}px)`, fontFamily: FONTE_U}}>
+    <div style={{background: COR.cartao, borderRadius: 28, boxShadow: SOMBRA.cartao, border: `1.5px solid ${COR.linha}`, padding: '30px 34px 24px', height: 190, position: 'relative'}}>
+      <div style={{fontSize: 30, color: texto ? COR.tinta : COR.mute, letterSpacing: '-0.005em'}}>
+        {texto || placeholder}{texto && texto.length < (digitar?.length ?? 0) && <span style={{display: 'inline-block', width: 2, height: 32, background: COR.tinta, marginLeft: 3, verticalAlign: -5}} />}
+      </div>
+      <div style={{position: 'absolute', left: 26, bottom: 22, width: 52, height: 52, borderRadius: 14, border: `1.5px solid ${COR.linha}`,
+        background: realce ? `rgba(41,38,31,${0.06 * realce})` : COR.cartao, display: 'flex', alignItems: 'center', justifyContent: 'center',
+        transform: `scale(${aperto})`, fontSize: 34, color: COR.tinta, lineHeight: 1}}>+</div>
+      <div style={{position: 'absolute', right: 26, bottom: 22, width: 52, height: 52, borderRadius: 14, background: COR.acento,
+        opacity: 0.35 + 0.65 * (texto ? 1 : 0), display: 'flex', alignItems: 'center', justifyContent: 'center'}}>
+        <svg width="24" height="24" viewBox="0 0 24 24"><path d="M12 19V5M5 12l7-7 7 7" stroke="#fff" strokeWidth="2.6" fill="none" strokeLinecap="round" strokeLinejoin="round" /></svg>
+      </div>
+    </div>
+    {atalhos.length > 0 && <div style={{display: 'flex', gap: 14, justifyContent: 'center', marginTop: 26}}>
+      {atalhos.map((a, i) => {
+        const q = eb(seg(f, inicio + 12 + i * 3, inicio + 26 + i * 3));
+        return <div key={i} style={{fontSize: 22, color: COR.mute, padding: '10px 20px', borderRadius: 999, border: `1.5px solid ${COR.linha}`,
+          background: 'rgba(255,255,255,0.6)', opacity: seg(f, inicio + 12 + i * 3, inicio + 18 + i * 3), transform: `scale(${0.9 + 0.1 * q})`}}>{a}</div>;
+      })}
+    </div>}
+  </div>;
+};