e2esim

func BalanceSheet ¶

func BalanceSheet(balances []model.AccountBalance) BalanceSheetResult

BalanceSheet classifies balances (as returned by TrialBalance) by account type. Asset accounts are debit-normal (balance = debit - credit); liability and equity accounts are credit-normal (balance = credit - debit).

func NewClient ¶

func NewClient(e *echo.Echo) (*Client, error)

NewClient wraps e in a Client with its own cookie jar (its own session).

func SeedDemo ¶

func SeedDemo(
	ctx context.Context,
	h *Harness,
	out io.Writer,
	seed int64,
	scale float64,
) (DemoStats, error)

SeedDemo populates h with the two public demo businesses documented in README.md — Toko Makmur Jaya (retail) and Kopi Selasar (coffee shop) — both owned by the same person, matching the real demo exactly. seed controls RNG reproducibility (offset by 1 for the second business, so a single --seed flag still determines the whole run); scale multiplies both businesses' daily order volume on top of their own baseline (see TokoMakmurJaya/KopiSelasar's doc comments for why that baseline was lowered from the old seeder's literal 100/day).

After both businesses are generated, SeedDemo verifies their books balance (TrialBalance, BalanceSheet, RevenueCrossCheck) before returning successfully — the seeded demo image is a real correctness check on the accounting engine, not just a data-population step.

func NewHarness ¶

func NewHarness(ctx context.Context, t0 time.Time, opts ...HarnessOption) (*Harness, error)

NewHarness builds a fresh app pinned to t0. Advance h.Clock to move the simulated "now" forward. By default it uses a throwaway in-memory database and a discarding logger — the right shape for tests and for RunPersona's own use; pass WithDBPath/WithLogger for a real seeding run (see cmd/seed.go) that needs to write to and log against a real database.

func WithDBPath ¶

func WithDBPath(path string) HarnessOption

WithDBPath points the harness at a real file-backed SQLite database (via repo.NewSQLiteDB, which configures WAL + busy_timeout + foreign_keys for a file path) instead of the default unique shared-cache in-memory database. Leave unset for tests.

func WithLogger ¶

func WithLogger(l *slog.Logger) HarnessOption

WithLogger routes the harness's internal logging (and, via slog.SetDefault, webhandler's package-level error logging — see the slog.SetDefault call below) through l instead of discarding it. Leave unset for tests.

func BankruptBusiness ¶

func BankruptBusiness() Persona

BankruptBusiness proves the ledger stays internally consistent even when the business it describes is failing: revenue plateaus for the first 40% of the year then collapses toward near-zero (CliffTrajectory), while rent and utilities stay FIXED — expenses don't decline just because revenue did, which is exactly what drives a real business into the ground. The accounting invariants (trial balance, balance sheet) don't require a healthy business, only a correctly-recorded one; this persona is the proof that a collapsing cash position (even a negative one, since nothing stops the ledger's Cash account from going negative — there's no "insufficient funds" check on recording an expense) still balances.

func BoomingBusiness ¶

func BoomingBusiness() Persona

BoomingBusiness is the opposite of BankruptBusiness: explosive growth over a short window (9 months) rather than a slow climb — two branches from day one (rapid expansion, not one branch growing in place) and a team hired up front to handle the scale-up, with volume growing more than 10x from start to end.

func FnBCafe ¶

func FnBCafe() Persona

FnBCafe proves the recipe/ingredient path end-to-end: a solo-owner coffee shop where every drink sold deducts ingredient stock (not its own stock — recipe products have none) and posts COGS computed from the recipe's components, not a flat per-product cost. Single branch/station and no staff, deliberately, so this persona isolates the recipe dimension from the multi-branch/multi-staff one (see MultiChain).

func GrowingSmallShopWithStaff ¶

func GrowingSmallShopWithStaff() Persona

GrowingSmallShopWithStaff proves three mechanisms SoloRetailShop can't: multi-actor login/claims (a cashier rings up orders under their own session, not the owner's), depreciation idempotency (one fixed asset, run-depreciation invoked monthly across a 6-month history), and discount creation/application (Persona.DiscountRate/Discounts, exercised end to end for the first time anywhere in this suite — see runner.go's createDiscounts/simulateOrder). Real upward Trajectory — first persona to actually tell a growth story.

func KopiSelasar ¶

func KopiSelasar() Persona

KopiSelasar ports the "Kopi Selasar" demo coffee-shop business from internal/seeddata/setup.go+catalog.go+assets.go verbatim — including all 8 recipes (the docs site says "six," but the code (ground truth) has always defined 8; this port follows the code). SharedOwner is left unset here — SeedDemo sets it to the already-registered Toko Makmur Jaya owner before running this persona, since both demo businesses belong to the same real-world owner.

func MultiChain ¶

func MultiChain() Persona

MultiChain proves branch-weighted traffic distribution and multi-staff station rotation: three branches with different traffic shares, several staff across all three non-owner roles (including one "inventory" role staffer, who must be excluded from POS station rotation entirely — see runner.go's assignStationActors). Retail archetype, kept separate from FnBCafe so this persona isolates the multi-branch/multi-staff dimension.

func SoloRetailShop ¶

func SoloRetailShop() Persona

SoloRetailShop is Round 1's minimum viable proof persona: a ~2.5-month-old single-branch, single-station retail shop with no staff at all — the owner does everything. Retail archetype (no recipes), gentle flat-ish trajectory, no fixed assets — keeps the first proof free of the multi-actor and depreciation dimensions covered by GrowingSmallShopWithStaff.

func SteadyGrowthBusiness ¶

func SteadyGrowthBusiness() Persona

SteadyGrowthBusiness grows consistently month over month for a year and a half — LinearGrowthTrajectory more than doubles daily volume from start to end, smoothly rather than via a dramatic event, and a cashier is hired to help handle the growing load.

func ThreeYearVeteran ¶

func ThreeYearVeteran() Persona

ThreeYearVeteran is a mature, long-running business: three years of history, a brief early ramp then a long flat plateau (an established customer base, not a startup), one staff member, and one fixed asset with a long useful life — long enough that run-depreciation has to catch up many periods across the full three-year span, not just one or two.

func TokoMakmurJaya ¶

func TokoMakmurJaya() Persona

TokoMakmurJaya ports the "Toko Makmur Jaya" demo retail business from internal/seeddata/setup.go+catalog.go+assets.go verbatim (names, logins, catalog, discounts, fixed asset) — everything documented in README.md and the docs site. AvgOrdersPerDayStart is deliberately lower than the old seeder's literal 100/day: at that volume, this engine's real HTTP+ accounting round-trips per order would take 20-30+ minutes for 2 years of history, vs. the old raw-SQL seeder's few seconds. ~18/day keeps --scale 1.0 (demo.Dockerfile's default) in the low single-digit minutes while still producing a substantial multi-year history.

func RunPersona ¶

func RunPersona(ctx context.Context, h *Harness, p Persona) (*Result, error)

RunPersona drives h through p's entire lifecycle — registration, company setup, branches/stations/staff/catalog, then a day-by-day simulated history — entirely via real HTTP requests against h.Echo. Every journal entry that results comes from accounting.Service.Handle, triggered by the real event-emission path (see enqueuer.go), not from any duplicated posting logic in this package. p is taken by value (not *Persona) deliberately: every persona builder (SoloRetailShop, TokoMakmurJaya, etc.) returns a Persona by value, and RunPersona is called exactly once per simulated business, not in a hot loop, so the copy is a one-time cost, not a perf concern.

func NewSyncEnqueuer ¶

func NewSyncEnqueuer(svc *accounting.Service, log *slog.Logger) *SyncEnqueuer

NewSyncEnqueuer returns a SyncEnqueuer that posts accounting jobs via svc.

func CliffTrajectory ¶

func CliffTrajectory(plateauMultiplier, cliffFraction, floorMultiplier float64) TrajectoryFn

CliffTrajectory holds steady at plateauMultiplier until cliffFraction of the timeline has elapsed, then declines linearly to floorMultiplier by the end — models a business that looks healthy and then collapses, rather than one that was always declining (LinearGrowthTrajectory with a high start and low end gives a steady decline instead; use that for a "slow bleed" persona and this one for a "sudden bankruptcy" persona).

func FlatTrajectory ¶

func FlatTrajectory(rampDays int) TrajectoryFn

FlatTrajectory ramps gently up over rampDays then holds steady — the default for a persona that isn't trying to tell a growth/decline story.

func LinearGrowthTrajectory ¶

func LinearGrowthTrajectory(startMultiplier, endMultiplier float64) TrajectoryFn

LinearGrowthTrajectory ramps from startMultiplier to endMultiplier evenly across the whole timeline. Passing a startMultiplier greater than endMultiplier produces a steady decline rather than growth.

func TrialBalance ¶

func TrialBalance(
	ctx context.Context,
	accountingRepo data.AccountingRepoer,
	companyID uuid.UUID,
) (*TrialBalanceResult, error)

TrialBalance sums every account's lifetime debit/credit totals for companyID.