@hotmeshio/long-tail 0.19.1 → 0.21.0

package/docs/compiler.md

@@ -1,311 +0,0 @@
-# The Workflow Compiler
-
-You wrote a durable workflow. It works. `proxyActivities`, `sleep`, `condition` — the durable API is productive and familiar. But under the hood, the durable engine replays the entire workflow function on every wake-up. Sleep three times in a ten-step workflow? Steps 1–3 replay on wake one. Steps 1–6 replay on wake two. Steps 1–9 replay on wake three. The replay is deterministic — it skips completed activities — but the function still executes from the top every time.
-
-The compiled YAML DAG does the same work without replay. Each step fires exactly once. State flows explicitly between activities through input mappings. No function re-execution, no replay loop, no wasted cycles.
-
-`ltc` is the compiler. It reads your TypeScript source and produces an equivalent YAML DAG. Write procedural because it's productive. Run the DAG because it's fast.
-
----
-
-## The Analogy
-
-`tsc` compiles TypeScript to JavaScript. You write in the language that's expressive. You run the artifact that's efficient. The source is authoritative — you edit it, test it, review it. The compiled output is what actually executes.
-
-`ltc` does the same for workflows:
-
-```
-  TypeScript source       ltc compile        YAML DAG
-  (developer-friendly) ──────────────────→ (execution-optimized)
-
-  assembly-line.ts     →   assembly-line.compiled.yaml
-```
-
-The `.ts` file is the spec. The `.compiled.yaml` is the optimized execution. Both live in the repo. A reviewer reads both side-by-side and traces every line of orchestration logic to its DAG equivalent.
-
----
-
-## Quick Start
-
-```bash
-npm install -g @hotmeshio/long-tail
-export ANTHROPIC_API_KEY=sk-ant-...
-
-ltc compile workflows/basic-echo/index.ts
-```
-
-Output:
-
-```
-  ✓ index.ts → workflows/basic-echo/index.compiled.yaml
-    1 activities · 2 inputs (message, sleepSeconds) · topic: basic.echo
-
-  Compiled 1 workflow in 18.1s
-```
-
-The compiled YAML appears adjacent to the source file.
-
----
-
-## Before and After
-
-### The source (procedural)
-
-```typescript
-import { Durable } from '@hotmeshio/hotmesh';
-import * as activities from './activities';
-
-const { echo } = Durable.workflow.proxyActivities<typeof activities>({
-  activities,
-});
-
-export async function basicEcho(envelope: LTEnvelope): Promise<any> {
-  const { message = 'Hello, Long Tail!', sleepSeconds = 1 } = envelope.data;
-
-  // 1. Durable sleep — the engine replays to this point on wake-up
-  await Durable.workflow.sleep(`${sleepSeconds} seconds`);
-
-  // 2. Activity call — replayed as a no-op if already completed
-  const echoResult = await echo({ message });
-
-  return {
-    type: 'return' as const,
-    data: { ...echoResult, sleepSeconds, userId: envelope.lt?.userId },
-  };
-}
-```
-
-This function executes three times: once on initial invocation, once when the sleep timer fires, and once when the echo activity completes. Each time, the engine replays from the top, skipping completed steps. For a two-step workflow this is fine. For a twenty-step workflow with multiple sleeps, the replay cost compounds.
-
-### The compiled output (DAG)
-
-```yaml
-app:
-  id: longtail
-  version: '1'
-  graphs:
-    - subscribes: basic.echo
-      expire: 300
-      input:
-        schema:
-          type: object
-          properties:
-            message:
-              type: string
-              default: 'Hello, Long Tail!'
-            sleepSeconds:
-              type: number
-              default: 1
-      activities:
-        trigger_m7qz:
-          type: trigger
-          output:
-            schema:
-              type: object
-              properties:
-                message: { type: string }
-                sleepSeconds: { type: number }
-
-        delay_m7qz:
-          type: hook
-          sleep: '{trigger_m7qz.output.data.sleepSeconds}'
-
-        echo_m7qz:
-          type: worker
-          topic: basic.echo
-          input:
-            maps:
-              message: '{trigger_m7qz.output.data.message}'
-              workflowName: echo
-
-      transitions:
-        trigger_m7qz:
-          - to: delay_m7qz
-        delay_m7qz:
-          - to: echo_m7qz
-```
-
-### The mapping
-
-| TypeScript | YAML | What happens |
-|---|---|---|
-| `envelope.data` destructuring | `trigger` activity with input schema | Inputs declared as typed schema with defaults |
-| `Durable.workflow.sleep(N)` | `hook` activity with `sleep` field | Engine sets a timer; no replay on wake |
-| `await echo({ message })` | `worker` activity with input `maps` | Worker fires once; result stored in job hash |
-| `return { data: ... }` | `job.maps` on the final activity | Output fields plucked from activity results |
-
-Each step executes exactly once. The `sleep` hook pauses the DAG. When the timer fires, execution resumes at `echo_m7qz` — not from the top of the function.
-
----
-
-## Discovery
-
-Point `ltc` at a directory and it finds workflow files automatically:
-
-```bash
-ltc compile examples/workflows/ --dry-run
-```
-
-```
-  Found 10 workflows:
-
-  ● assembly-line/index.ts
-    Function: assemblyLine  ·  HotMesh Durable
-    Control flow: startChild, condition
-
-  ● basic-echo/index.ts
-    Function: basicEcho  ·  HotMesh Durable
-    Activities: echo
-    Control flow: sleep
-
-  ● basic-signal/index.ts
-    Function: basicSignal  ·  HotMesh Durable
-    Activities: ltCreateEscalation, processApproval
-    Control flow: conditional
-
-  ● kitchen-sink/index.ts
-    Function: kitchenSink  ·  HotMesh Durable
-    Activities: greet, fetchData, transformData, notifyComplete
-    Control flow: sleep, executeLT
-```
-
-### What the scanner looks for
-
-| Pattern | Classification |
-|---|---|
-| `proxyActivities` / `Durable.workflow.proxyActivities` | HotMesh Durable workflow |
-| `@temporalio/workflow` import | Temporal workflow |
-| `sleep`, `condition`, `signal` | Control flow primitives |
-| `startChild`, `executeChild`, `executeLT` | Composition (parent workflow) |
-| Exported async function | Workflow entry point |
-
-Files in `node_modules/`, `build/`, `dist/`, and test files (`*.test.ts`, `*.spec.ts`) are excluded.
-
----
-
-## How Compilation Works
-
-The compiler is not an AST parser. It uses the LLM to translate orchestration logic, grounded by structural metadata extracted from the source.
-
-1. **Read source** — file or inline string
-2. **Extract metadata** — lightweight regex extraction: activity names, durable primitives, envelope fields, import paths, control flow markers (loops, Promise.all, conditionals, escalation)
-3. **Resolve activities** — if the source imports activity modules, the compiler reads them too and includes them in the LLM context
-4. **LLM translation** — the source code, extracted metadata, and the full HotMesh YAML specification are sent to the LLM. Temperature 0. Up to 3 retry attempts on parse failure.
-5. **Fix patterns** — known LLM anti-patterns in YAML pipe expressions are corrected deterministically
-
-The metadata extraction is intentionally lightweight — regex, not a TypeScript AST. It gives the LLM structural hints (which functions are activities, which primitives are used) without requiring `ts-morph` or the TypeScript compiler API as a dependency.
-
----
-
-## Composition
-
-When a workflow uses `startChild` or `executeChild`, the compiler resolves the child workflow source through imports and compiles children first (leaf-first ordering). The parent's compiled YAML references each child by topic using the `await` activity type — the same mechanism used by the Pipeline Designer's Plan Build mode.
-
-```
-parent.ts  ──→  parent.compiled.yaml
-  └─ startChild(worker)
-       └─ worker.ts  ──→  worker.compiled.yaml
-```
-
-All compiled workflows in the same composition share the same `app.id` namespace, enabling cross-graph invocation.
-
----
-
-## Three Surfaces
-
-The compiler is the same function regardless of how you invoke it.
-
-### CLI
-
-```bash
-ltc compile workflows/assembly-line.ts
-ltc compile src/workflows/ --dry-run
-ltc compile --model claude-sonnet-4-6
-```
-
-### HTTP API
-
-```bash
-curl -X POST http://localhost:3000/api/yaml-workflows/from-durable \
-  -H "Authorization: Bearer $TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "source": "export async function basicEcho(envelope) { ... }",
-    "workflow_name": "basicEcho",
-    "name": "basic_echo"
-  }'
-```
-
-### SDK
-
-```typescript
-import { createClient } from '@hotmeshio/long-tail/sdk';
-
-const lt = createClient({ auth: { userId: 'system' } });
-
-const result = await lt.yamlWorkflows.compileDurable({
-  source: fs.readFileSync('workflows/assembly-line.ts', 'utf-8'),
-  workflow_name: 'assemblyLine',
-  name: 'assembly_line',
-});
-```
-
-The CLI writes `.compiled.yaml` files to disk. The HTTP and SDK surfaces store the compiled workflow in the database and return the record. All three use the same underlying `compileDurableToYaml()` function.
-
----
-
-## Configuration
-
-| Variable | Default | Description |
-|---|---|---|
-| `ANTHROPIC_API_KEY` | — | Required for Claude models |
-| `OPENAI_API_KEY` | — | Required for OpenAI models |
-| `LT_LLM_MODEL_PRIMARY` | `claude-sonnet-4-6` | Model used for compilation |
-| `LT_LLM_BASE_URL` | — | Custom endpoint for OpenAI-compatible models |
-
-The CLI loads `.env` automatically if present in the current directory.
-
----
-
-## CLI Reference
-
-```
-Usage: ltc compile [options] [target]
-
-Compile durable TypeScript workflows to YAML DAGs
-
-Arguments:
-  target                  File or directory to compile (default: current directory)
-
-Options:
-  --dry-run               Show discovered workflows without compiling
-  -o, --output <dir>      Output directory (default: adjacent to source file)
-  --model <model>         LLM model to use (default: claude-sonnet-4-6)
-  --function <name>       Workflow function name (auto-detected if omitted)
-  -h, --help              Display help
-```
-
-### Examples
-
-```bash
-# Compile a single file
-ltc compile workflows/basic-echo/index.ts
-
-# Scan and compile all workflows in a directory
-ltc compile src/workflows/
-
-# Compile everything in the current directory
-ltc compile
-
-# Preview what would be compiled
-ltc compile examples/workflows/ --dry-run
-
-# Use a specific model
-ltc compile workflows/complex.ts --model claude-opus-4-6
-
-# Write output to a separate directory
-ltc compile workflows/ -o compiled/
-
-# Compile a specific function from a multi-export file
-ltc compile workflows/multi.ts --function assemblyLine
-```

package/docs/contributing.md

@@ -1,56 +0,0 @@
-# Contributing
-
-## Running the Demo
-
-The repository includes a working server with example workflows (`reviewContent`, `kitchenSink`, `basicEcho`, and more), Postgres, NATS, and a React dashboard.
-
-### Prerequisites
-
-- [Docker](https://docs.docker.com/get-docker/)
-
-### Run
-
-```bash
-git clone https://github.com/hotmeshio/long-tail.git
-cd long-tail
-docker compose up
-```
-
-Postgres, NATS, the API server, and the dashboard start together. The dashboard is built during the Docker image build and served as static assets. Migrations run automatically.
-
-Default ports are `3000` (API), `5432` (Postgres), `4222`/`8222` (NATS). Override any of them:
-
-```bash
-LT_PORT=3001 LT_PG_PORT=5433 LT_NATS_PORT=4223 docker compose up
-```
-
-## Testing
-
-```bash
-# Start Postgres and NATS
-docker compose up -d postgres nats
-
-# Run all tests
-npm test
-
-# Run workflow tests
-npm run test:workflows
-```
-
-## Development Setup
-
-1. Fork the repository and clone your fork
-2. Install dependencies: `npm install`
-3. Start infrastructure: `docker compose up -d postgres nats`
-4. Run tests to verify your setup: `npm test`
-
-## Pull Requests
-
-- Create a feature branch from `main`
-- Keep changes focused — one concern per PR
-- Add or update tests for any new behavior
-- Run `npm test` before submitting
-
-## Issues
-
-Report bugs and request features at [github.com/hotmeshio/long-tail/issues](https://github.com/hotmeshio/long-tail/issues).

package/docs/design-principles.md

@@ -1,244 +0,0 @@
-# Design Principles
-
-The design system behind the dashboard and every generated x-lt-* form. One
-token vocabulary, one value discipline, one form doctrine — the built-in pages
-and the forms customers author render from the same rules.
-
----
-
-## 1. Tokens are the system
-
-Every color, size, radius, and spacing knob flows through a `--lt-*` CSS
-variable declared in `dashboard/src/styles/globals.css`. Nothing paints a raw
-hex. A registered stylesheet (`branding.customCss` / `branding.themes` in
-`start()`) can therefore restyle the entire product — including full dark
-themes — with zero source changes. Midnight is the standing proof: if a color
-escapes the token system, it glows in the dark.
-
-Deliberate exceptions, each carrying a stated constraint in code: the
-signature pad (the exported PNG is a document — ink on white), customer
-iframes (their HTML assumes a white canvas), OAuth brand marks, theme-picker
-swatches, and overlay scrims.
-
-## 2. Color — the value discipline
-
-Chroma is spent, not spread.
-
-- **Surfaces are near-neutral; lines carry the hue.** Hover fills and section
-  bands stay a whisper off-neutral, but the thin structure — borders,
-  dividers, outlines, field rules — carries a clear, light tint of the accent
-  so the frame reads as thematic. Chroma never lands on a large rectangle — a
-  colored slab makes every real accent invisible — but a hairline may glow.
-- **One elevation logic, both polarities.** The page carries the base wash
-  (a light theme tint by day, the deep shade at night); sections and sheets
-  are distinct surfaces on it (white paper by day, the deeper well at
-  night); fields are wells that step AWAY from their surface (darker than
-  white by day, lighter than the shade at night). Light is Midnight
-  inverted — never a flat white page with white sections.
-- **The accent appears in small doses**: links, buttons, checks, pills,
-  section labels, focus states. Because it is scarce, it reads as "act here."
-  Icon links follow the same rule in every theme: clickable glyphs (toolbar
-  icons, view toggles) render through the `.icon-link` recipe — muted accent
-  at rest, full accent on hover — never a neutral text tone, which reads as
-  a static mark.
-- **Dark themes are the same principle, inverted** — near-black neutral
-  surfaces, the identical accent discipline. Midnight is not a different
-  design; it is the same design at night.
-- **Status is information, not decoration.** Text-safe status tokens
-  (≥4.5:1) for words; brighter `-graphic` variants for dots, bars, and
-  charts (≥3:1).
-- **The focus fill is the one ambient accent moment** — entering a field
-  earns the tint.
-
-## 3. Text — black speaks, color acts
-
-- One neutral near-black ramp shared by every light theme: `#171717` body,
-  `#373737` labels, `#646464` helper, `#8C8C8C` low-emphasis meta. Labels are
-  never theme-colored — a tinted label is indistinguishable from a link.
-  If it's colored, it must be clickable.
-- **11px floor.** No informative text below `text-2xs`. Quaternary tone is
-  reserved for large or decorative text (≥3:1).
-- **Headings**: near-black (`#333333`), small caps, weight 300, generous
-  sizes — `heading-1` (2.125rem) / `heading-2` (1.5rem) / `heading-3`
-  (1.25rem). The size carries hierarchy; the light weight keeps it elegant.
-  Mono identifiers (role keys, workflow types, topics) stay code-styled,
-  never small-caps.
-
-## 4. Fields and controls
-
-- **One recipe** (`.field/.input/.select/.textarea`): white body, a light
-  accent-tinted border, soft radius (`--lt-radius-field`), border deepens to
-  accent and fill takes the theme tint on focus. Every field-like control uses
-  the recipe or the tokens — no bespoke field styling.
-- **Width follows content, capped by the measure:**
-  - Generated forms hold a readable measure (`max-w-form`, 56rem). A wide
-    monitor gets margin, never a 2000px input.
-  - Selects size to their content, floored at 16rem for presence — a
-    one-word choice never stretches across the page. The floor yields to
-    the cell (`min(16rem, 100%)`): CSS lets min-width beat max-width, so
-    a bare floor would overflow a narrow column.
-  - Number and date inputs hold a hand-sized width (12rem; datetimes
-    16rem) — fixed-length values never stretch to the measure.
-  - Text, textarea, email, and url fill their cell — prose-length content
-    deserves the measure.
-  - Widgets follow the same split. Prose surfaces (code editor, markdown,
-    rich text, uploads) fill the cell. The signature pad holds its natural
-    document proportion (25rem, the 400×150 export) — the PNG is the
-    artifact, and stretching the pad stretches the document.
-- **Decisions are never checkboxes.** A decision is an enum opening on an
-  explicit disabled **Choose…** placeholder. The user picks; nothing is an
-  implicit first option, and there is no way back to unchosen.
-- Checkboxes exist only inside checklists — confirmations of work, not
-  choices.
-- **Item length and selection mode determine list geometry.**
-  Sentence-length require-all *rituals* read top-down, one per row — the
-  vertical stack is deliberate. Short pick-any *tags* (reasons, categories)
-  flow horizontally as selectable chips: thumb-sized pills that wrap,
-  selection in solid accent. Never stack six two-word items into six
-  full-width rows — endless y with an empty x is a dead layout.
-- **Required is marked, everywhere.** Every required input — text, select,
-  number, upload, checkbox, or checkbox group — carries the red asterisk at
-  its label. A require-all checklist is required by definition and marked
-  like the rest. Required or optional is never a guess.
-
-## 5. Layout — the canonical shell
-
-```
-┌──────────────── Header (full width) ────────────────┐
-│ left nav │        main viewport        │ right panel │
-└──────────────── EventFeed (full width) ─────────────┘
-```
-
-- Header and event-stream footer span the full width. The left nav and the
-  global right SlidePanel are flex siblings of the main viewport — content
-  narrows when either opens; nothing overlays it. Pages fill the right panel
-  via `useShellPanel()`. The DocsDrawer is the full-screen overlay for
-  markdown.
-- iPad (768–1366) is the floor target: page padding clamps down, the sidebar
-  auto-collapses below 1024, nothing depends on hover alone.
-- Structure comes from typography, whitespace, and divider lines — never
-  rounded-bordered cards, never gradient fades. Sections sit on a barely
-  sunken band with an accent left rule.
-
-## 6. The form doctrine
-
-The reference implementation is `examples/workflows/acme-stations` — mimic it.
-
-1. **Facts first, as a dictionary.** Read-only work-item facts render as a dense
-   label/value spec sheet (`x-lt-display: "dictionary"`), not form rows.
-2. **One explicit decision** gates the form. Until it is made the page shows
-   facts, the decision, nothing else — even sign-off waits.
-3. **Linear reveals.** Each outcome fades in exactly the section it needs
-   (`x-lt-showIf` value matches). The enter animation makes the
-   cause-and-effect visible in time: click Reject, watch the report arrive.
-4. **The left/right law.** Left and Right always render side by side, Left
-   first — as dictionary pairs (two-column dictionaries fill row by row, so
-   consecutive items share a row) and as inputs (`x-lt-column-group` pairs
-   them in one cell, the 2×2).
-5. **Checklists**: standard confirmations may arrive pre-checked
-   (formDefaults) — the standard is the default and the resolver unchecks
-   what isn't true. The work item's own custom work arrives unchecked; those
-   clicks are the record. `x-lt-require-all` guards completion.
-6. **Every input carries a `title` and one instructional `description`
-   line — no input goes without.** The anatomy is fixed and identical for
-   every input kind: label, instruction, control, in that order. The
-   anatomy is a declared column, never an accident of width — the label is
-   a block, so a narrow control (a number, a short select) can never ride
-   sideways beside it when the instruction line is absent. Inputs that
-   share a row carry instructions of similar length so their controls align
-   across the row; a bare input beside an instructed one is a consistency
-   defect, in both content and alignment. The WHY — reference tables,
-   consequences, vocabulary — lives in `x-lt-help` beside the form.
-7. **Sign-off last.** A short audit note with a live counter.
-8. Hidden conditional fields still submit their defaults; resolver contracts
-   treat empty as absent.
-
-## 7. Copy — the economist tone
-
-The escalation `description` is the detail page's title: a short noun
-phrase naming the artifact — "Final QA — ACME-1042 · wgt-8127" —
-never a sentence, never an instruction, never a status report.
-
-Say what to do. Speak to the actor, in the imperative, always: "Pick Reject
-to file a report" — never "Reject files a report." The system is never the
-subject of an instruction, and passive voice never appears. One line per
-instruction; consequences ride the same sentence ("Resolve — the widget moves
-on to assembly"). Reference tables over paragraphs. Never preachy, never
-motivational, never "you're the first human — do well." State what a thing is
-and does, never what it lacks.
-
-## 8. Motion
-
-Motion explains causality; it never decorates. Reveals fade in tied to the
-choice that caused them (200–300ms enter). Errors shake once and settle.
-Panels slide as flex siblings so content reflows rather than being covered.
-Nothing loops, nothing floats.
-
-## 9. Accessibility floors
-
-- Body and label text ≥4.5:1; large/meta text and graphics ≥3:1.
-- Every input is label-associated; errors and helpers ride
-  `aria-describedby`; the errors panel click-focuses the field
-  (`data-field-key` is a contract).
-- Disabled forms use `inert` — out of the tab order, not just grayed.
-- `color-scheme` follows the theme so native controls match the surface.
-
-## 10. Responsive — geometry follows the container
-
-1. **Geometry follows the container, not the viewport.** Side panels, the
-   facet drawer, and the nav rail narrow containers below any viewport
-   breakpoint — a `md:`/`lg:` variant on a content grid is a defect.
-   Viewport variants are lawful only in the shell frame (header, nav rail),
-   where the viewport is the container.
-2. **Thresholds are named container tokens** (tailwind `containers`):
-   `@dict-inline` 22rem · `@grp-cols` 26rem · `@form-cols` 34rem ·
-   `@filters` 72rem · `@dict-pairs` 38rem · `@table` 48rem. Components use
-   the names, never raw rem values. A fold threshold is sized for the
-   HEAVIEST content its component carries — escaping to the condensed
-   format early beats ever letting a bar wrap.
-3. **The dictionary reflow ladder** — the poster child. The same
-   label/value pairs render as: two pairs per row at `@dict-pairs`; one
-   label|value pair per row at `@dict-inline`; label stacked over value
-   below. Pairing order never changes across geometries.
-4. **A table row IS a dictionary.** Below `@table`, tables fold into dense
-   console-style cards — identity columns become the title line, the rest
-   fold into label/value pairs on the dictionary ladder. **Tables never
-   scroll horizontally** — master lists use `layout="fixed"` so a table
-   physically cannot outgrow its container. Fixed columns cut both ways:
-   **cell content never bleeds into a neighbor** — every cell clips
-   (`overflow-hidden` on the `td`) and every text-bearing pill or label
-   truncates with an ellipsis (`max-w-full` + `truncate`), carrying the
-   full value in `title` for hover reveal.
-5. **The column budget, disclosed both ways.** The floor set — identity,
-   owner, urgency, age — always renders. Enrichment columns (workflow,
-   metadata facets) return only when the table's container has room
-   (`showFrom: '@split' | '@wall'`); below that they fold into card pairs.
-   The list is a jumping-off spot: the ELK-style drill the whole product
-   surfaces.
-6. **Refining is a ROW gesture, never a cell tax.** Cells spend their full
-   width on data. One always-visible magnifier per row (or board card)
-   opens the refine dialog: the row's metadata-bound facts as full-width
-   touch rows, multi-select ANDing facets, with filter-in-role /
-   search-everywhere / add-to-filters actions. Per-cell icon pairs are a
-   defect — twelve columns × two icons starves every value into an
-   ellipsis. Hover-only affordances do not exist on the floor.
-7. **Disclosure order**: drop priority-3 columns, fold priority-2 into
-   pairs, keep priority-1 always.
-8. **Touch parity**: every hover-only affordance has a tap equivalent —
-   the iPad floor has no hover.
-9. **The header diet ladder** (below lg): mark-only logo, icon+count links,
-   secondary actions fold into the user menu, the nav rail becomes a
-   drawer behind a menu button.
-10. **Sticky elements are never containers** — `container-type` breaks
-   `position: sticky` on the same element; wrap the geometry element
-   instead.
-
-## 11. Never
-
-Raw hex in components. Chroma on large surfaces. Theme-colored labels.
-Text below 11px. Decisions as checkboxes. Implicit select defaults.
-Full-width one-word inputs. Tag lists stacked as rows. Unmarked required
-fields. Inputs without instruction lines. Passive voice or system-voice
-copy. Horizontal scroll. Viewport breakpoints on content grids. Cards and
-gradient fades. "Back to X" links. Polling. Preachy copy. Customer names —
-the showcase brand is always Acme.