pkg/

Package apidoc renders the framework's public Go API from its sources as the app resolves them (its go.mod, replace directives included), so an agent reads the signatures it can call instead of guessing them.

Package brief is an app's brief: what it is for, who owns the data, how it looks, which services it uses, where it runs and how agents work on it, answered by the people who own the app.

Package civil holds dates and times as people write them, with no time zone: Date is a calendar day (a schema.lidza date field, a Postgres date column), DateTime a wall-clock time as a form's date-time input sends it (a schema.lidza localtime field).

Package config reads lidza.json, the per-project configuration.

Package configref builds docs/configuration.md, the reference of every setting a Līdza app reads, from the framework's source: the env tags of the packs' Config structs, the Env constants, and the settings read by name, each with its doc comment.

Package credentials keeps an app's secrets encrypted at rest: config/credentials.yml.enc holds KEY: value pairs sealed with AES-256-GCM under the master key in config/master.key (never committed) or LIDZA_MASTER_KEY (production).

Package crud generates a resource from a schema.lidza model: the sqlc queries, the Create and Update types, a handlers file with the five typed routes, and the registration in routes.go.

Package decimal is the Go type of a schema.lidza decimal(p, s) field, a Postgres numeric(p, s) column: an exact decimal number kept as its text, "12.50", never as a float.

Package decisions keeps an app's decision log, docs/decisions.md: why the app is built the way it is (a pack added, Rust chosen for a module, a dependency taken, a schema tradeoff), one dated entry each, written by people and agents alike and read before working in those areas.

Package devserver is the Līdza dev server: the reverse proxy that puts the Go control plane and the frontend dev server behind one port, the static file server used in production, and the coordinator that keeps the app binary rebuilt while `lidza dev` runs.

Package diag runs the checkers for every layer of a Līdza project (Go, Rust, frontend) and merges their output into one list of diagnostics with a layer, file, line and message each.

Package engine runs pack WASM modules in wazero: a module compiled once, a bounded pool of pre-warmed instances, and calls with a deadline that pass JSON through linear memory (the ABI in core/src/abi.rs).

Package env fills a configuration struct from the environment, so secrets and per-deployment settings never live in lidza.json or code.

Package inspect reads a Līdza project's source and produces the context an agent needs: the API routes with their handler signatures, the Rust exports, and the configuration.

Package jsonschema derives a JSON Schema from a Go type at runtime, for app-defined MCP tools whose input is a Go struct.

Package lidzatest starts an app for a Go test: packs started against .env.test, the handler on an httptest server, and a JSON client.

Package list reads what a list route was asked for: a page (limit and offset, capped), a search, a time range, a sort among the allowed keys and equality filters, from the query string, validated, so a handler passes them to its query and nothing it did not allow reaches SQL.

Package mcpserver is `lidza mcp`: a Model Context Protocol server over stdio that gives an agent the project's route map, context, diagnostics, configuration and the runtime log of `lidza dev`, so it asks instead of grepping.

Package middleware holds the request pipeline every Līdza app runs: panic recovery, request ids, request logging, per-request deadlines, body limits, CORS and secure headers.

Package pack implements Līdza packs: a directory under packs/ with a manifest, a Rust crate compiled to WASM, and a generated Go wrapper that exposes each capability as a typed method backed by the engine.

Package recipes turns the "Recipes" section of an app's guide (docs/lidza-guide.md) into task recipes: prompts served by `lidza mcp`, and skills for Claude Code (.claude/skills) and for Codex and Gemini CLI (.agents/skills, the Agent Skills layout both read; Gemini offers each as a /<name> command).

Package report is the seam between the places errors surface (panic recovery, typed handlers, the frontend) and whatever collects them (the analytics pack).

Package resilience holds the circuit breaker outbound calls run through, so a failing dependency sheds load fast instead of tying up every request until its timeout.

Package router is the Līdza control plane's HTTP router: the API routes an application registers, plus the built-in ones every app serves.

Package scaffold implements `lidza new`: it copies a template and writes the Go entrypoint, lidza.json and the agent instruction files.

Package schema parses schema.lidza, the single source of truth for an application's data shapes, and generates Go structs with validation, the Postgres DDL and migrations, Rust serde structs and TypeScript types from it.

Package sdk generates the client SDKs from a project's operations.

Package secrets recognises the secrets providers issue (API keys, tokens, private keys, database URLs with a password) in a string: what lidza check refuses in code (L010) and what the audit pack redacts.

Package snippets embeds the files of the reference app (examples/notes) that show how the common tasks are done: an owned resource, auth routes, a page on the generated client, a handler test, a browser test, an MCP tool.

Package telemetry gives every app /metrics (Prometheus exposition, OpenTelemetry-compatible), /healthz (liveness) and /readyz (readiness: every service that can check itself is asked).

Package tracing is Līdza's OpenTelemetry tracing: opt-in, configured by the standard OTEL_* environment variables, exported over OTLP/HTTP.

Package validate holds the rules generated Validate methods call and the error type they return.

Package version reports the Līdza build version.

Package webhook receives a provider's webhooks safely: the signature is verified on the raw body before anything decodes it, deliveries outside the replay window are refused, and each delivery id is handled once.