@hypequery/cli

Add hypequery skill install: writes hypequery's agent skills (hypequery-datasets, hypequery-query) where Claude Code (.claude/skills/), Cursor and Codex (.agents/skills/) load them. --agent, --scope project|user, --check for CI and --force; re-runs are idempotent and edited skills are never replaced without --force.

Running hypequery with no command in an interactive terminal now starts hypequery init instead of printing help, so npx hypequery takes new users straight into setup. A one-line hint points to hypequery --help for the full command list. When the CLI is not attached to a terminal (scripts, CI, piped input), the bare command still prints help and exits with code 1, so nothing waits on a prompt.

generate:datasets and init --style datasets now read each table's engine from system.tables, so scaffolded datasets no longer count rows ClickHouse hasn't merged yet. ReplacingMergeTree tables get rowResolution: { kind: 'final', engine: 'replacing' } (with deletedColumn when the engine has one), and CollapsingMergeTree / VersionedCollapsingMergeTree tables get the matching signColumn resolution. Version, sign and deleted columns are no longer summed or averaged. Pre-aggregated tables drop the row-count measure: AggregateFunction columns become measure.merge(...) measures (parametric states such as quantile(0.9) are noted and skipped), SimpleAggregateFunction(sum|min|max, …) columns use that function, and SummingMergeTree tables sum only their summing columns (without a list, numeric columns outside the sorting key). If the engines can't be read, tables are scaffolded as before.

Add hypequery export:client-contract <api-file>. It writes the client contract of a TypeScript serve API (client-contract.json by default) for hypequery generate:client, with --output, --stdout, --check and --force, matching Python's hypequery export client-contract. Like Python, it refuses a contract with no endpoints.

Report ClickHouse connection failures accurately:

• generate, generate:datasets, and dev no longer report "Connected to ClickHouse" with 0 tables when the database is unreachable or rejects the credentials. They now show the real error.
• A refused connection now shows its message and troubleshooting hints instead of an empty error.
• The ClickHouse client's raw stack-trace logging is off, so commands show only their own error output.
• hypequery dev showed Docs and OpenAPI URLs without the base path for createAPI entries (for example /docs instead of /api/analytics/docs). It now shows the routes the API actually serves.

hypequery --help now describes the CLI as "Type-safe embedded analytics on ClickHouse", matching the website and README.

Telemetry now attributes an invocation that Commander rejects for a bad option or argument (for example hypequery dev --bogus) to the command that was requested, instead of reporting it as unknown. Mistyped commands are still unknown, now with an optional suggested_command taken from the CLI's own "Did you mean" suggestion; the raw input is never recorded.

Type generation now gives parameterized views their columns. ClickHouse describes such a view as having no columns, so the generated type was empty. The generator now describes a call to the view with each parameter's default value, and adds a comment that lists the parameters. Each table is now described once instead of twice. SimpleAggregateFunction(fn, T) columns are typed by T in the generated record interfaces.

hypequery generate:client --cloud generates typed React routes and types from the live Cloud release of the target chosen with hypequery login (or --project, --environment and --endpoint with HYPEQUERY_API_TOKEN). The file also exports clientBaseUrl, the origin the environment is served from. deploy --client <path> regenerates that file after each live publish; if regeneration fails, the deploy still succeeds and the CLI prints the command to retry.

hypequery deploy and deployment:build warn when a served dataset has a customer-like column (tenant_id, org_id, organization_id, organisation_id, account_id, customer_id, workspace_id or company_id) in a dimension, measure or filter, and neither the dataset nor its endpoint is scoped by tenant. Without that, every caller can read every customer's rows. The warning names the tenantKey line to add, or says to mark the dataset shared in Cloud. The cloud.ts scaffold now explains what empty roles and scopes allow.

Support deploy --draft <name> and deployment:submit --draft <name> for named Cloud code drafts. Draft uploads preserve Production, validate the returned draft and staging URL, and print staging details instead of Production endpoints.

generate:client names the output path it refuses, and why: the symbolic link or non-directory ancestor it found, with the same path written without the link (for example /tmp → /private/tmp on macOS). An ancestor that is a file is now reported as such, not as a bare ENOTDIR.

Name the field when a client contract has one this version doesn't know. ProtocolClientContractError gains an optional field: for HQ_CLIENT_UNKNOWN_FIELD, the first unknown member at path (whose value, the parent object, is unchanged). hypequery generate:client reports where it is (for example /endpoints/0/annotations) and suggests upgrading @hypequery/cli, since the contract usually comes from a newer hypequery.

generate:datasets now maps ClickHouse column types by their exact outer type, the same mapping Cloud uses, instead of by substring. Previously Point, Array(Int32) and Tuple(Float64, Float64) became dimension.number() (with sum/avg measures), and Array(String) and Map(...) became dimension.string(), so the generated catalog advertised scalars that queries then failed on. Each scalar element of a named Tuple now becomes its own dimension through tupleElement, named <column><Element> (pickupCity). Other composite columns (Array, Map, unnamed Tuple, geo, JSON) are left out with a comment in the generated file. Only date/time-typed columns are picked as timeKey, and totalCount counts a column that is actually a dimension.

Generated field names no longer clash. A field name is also its SQL alias, and ClickHouse resolves an alias before a column of the same name, so a field only takes a source column's name when it reads exactly that column. Otherwise it takes a numeric suffix (fareTotal2), with a comment saying why: with columns fare_total and fareTotal, the real fareTotal column keeps its name. Measure names (totalCount, totalX, avgX) follow the same rule, so a count column or a fare/Fare pair no longer produces duplicate keys.

Client contracts can carry an optional annotations member per endpoint: the dataset group's label/description and per-dimension/measure fields text (RFC 0018 amendment). Text follows the deployment contract's rules (non-blank, no control characters, at most 4096 UTF-8 bytes) and is excluded from schemaHash, so rewording a description never trips the execution-time schema pin; contentHash still covers it. The MCP HTTP bridge's list_datasets now shows each group's own description (and label) instead of the generic text, and get_dataset_schema returns the annotations with each endpoint profile. generate:client emits them as JSDoc on each ClientApi entry and output row field. Upgrade these packages before pointing them at a backend that emits annotations: earlier validators reject the new member.

Add isNull and isNotNull comparisons, which take no value (RFC 0023), so "has a churn date" is churned_at IS NOT NULL rather than a sentinel range. A protocol comparison using one is { kind: 'comparison', operator: 'isNotNull', left } with no right; a client query filter is { field, operator: 'isNull' } with no value. Validators reject a value on them and accept any field type. Measure fixed filters and segments can use them directly, including through the new isNull(field) and isNotNull(field) helpers (also re-exported by @hypequery/serve). Caller query filters are opt-in: a filter allows them only when its operators list names them, so default operator lists, and the identity of every existing deployment and client contract, are unchanged. The deployment data plane, the MCP dataset guide and the generated client input types support them, and the conformance corpus pins the new cases. Upgrade every consumer before publishing a contract that uses them: earlier validators reject the new operators.

Add MCP stdio bridging and discovery-only self-tests for authorized Python HTTP client contracts with --client-contract-url. Read Bearer credentials from HYPEQUERY_API_KEY, keep tenant resolution in Python, and abort discovery on shutdown.

Add offline generate:client generation of self-contained API types, installed POST route mappings and schema hashes from validated Python client contracts. Preserve typed filters, nullable wire values, metric aliases and default measures, with drift checks and explicit replacement of existing generated files.

@hypequery/serve is now an optional peer dependency. Installing @hypequery/cli in a frontend project, for example to run generate:client for a Python backend, no longer makes npm install the server packages too. hypequery dev says to install @hypequery/serve when it is missing.

Upgrade dotenv to v18 and load env files quietly, so dotenv's "injected env" log lines no longer appear in CLI output.

Serve accepts your schemas from Zod 3 or Zod 4. Query inputs and outputs are typed against a structural ServeSchema instead of Zod 3's ZodTypeAny, so npm install zod (which now resolves Zod 4) works with the quick start, and existing Zod 3 projects keep compiling. Query-string coercion and the OpenAPI document read both majors. The optional zod peer range is now ^3.23.8 || ^4.0.0.

Serve and MCP now depend on zod@^4.6.6 (was ^3.23.8), clearing GHSA-mrhx-c7xc-m3w5. For dataset and metric endpoints, whose schemas Serve builds, VALIDATION_ERROR issue text and codes now follow Zod 4 (for example Invalid option: expected one of …, and no received field). Endpoints with your own schemas report whatever your Zod reports, as before.

hypequery init scaffolds zod@^4.6.6.

Enable CLI telemetry by default. Unless opted out, the CLI now sends pseudonymous usage events to Hypequery's first-party endpoint (https://hypequery.com/api/telemetry) without needing HYPEQUERY_TELEMETRY_URL, which now only overrides the endpoint for staging or self-hosting. Events never include code, SQL, names, paths or credentials; see https://hypequery.com/docs/telemetry for every field. A one-time notice appears on the first interactive run. Opt out with hypequery telemetry disable, --no-telemetry, DO_NOT_TRACK=1 or HYPEQUERY_TELEMETRY_DISABLED=1.

Add staged generation metrics: actual filtered table and column count buckets, known fallback type families, dataset check/diff modes and drift results, warning-code buckets, and manifest/registry count buckets. Exclude schema names, type expressions, warning text, paths, and endpoint contents. Default collection remains inactive.

Add staged dev and MCP session telemetry with one start/end pair, bucketed reload and load-failure counts, and aggregate MCP tool-kind and error counts. Preserve MCP stdout for JSON-RPC and exclude paths, client identity, names, tenants, and tool arguments. Default collection remains inactive.

Add persistent telemetry preferences, hypequery telemetry status|enable|disable, and a global --no-telemetry flag. Honor DO_NOT_TRACK=1, HYPEQUERY_TELEMETRY_DISABLED=1, and test environments. Default collection remains inactive; maintainers can activate the staged core with HYPEQUERY_TELEMETRY_DEBUG=1 or HYPEQUERY_TELEMETRY_URL.

Define the v1 event catalog (command completion and crash events) with strict property validation, bucketed measurements, and a generated public event reference that lists only data the CLI sends. Unknown fields and content-bearing values are rejected before a payload can be constructed.

Add pseudonymous identity, local environment context, a one-time stderr disclosure, dependency-free bounded batch delivery, debug inspection, a per-version kill switch, and centralized command exit handling. Preserve command output and exit codes when telemetry is disabled or fails. No telemetry runtime dependency is added.

Instrument the init onboarding funnel in staged mode with progress, failure stages, scaffold choices, bucketed counts, and configuration-file outcomes. Preserve a single completion event across retries and classify early setup declines as cancellations. Honor Commander's --no-example option when scaffolding.

Deliver telemetry from a detached sender process instead of a 40 ms in-process request. The command exits without waiting on the network, while the sender gets up to five seconds, so batches survive TLS handshakes and serverless cold starts. The per-version kill switch (HTTP 410) is now applied by the sender.

hypequery mcp <file> and hypequery dev <file> now work from any working directory. TypeScript entries are bundled into .hypequery/tmp beside the entry's nearest package.json instead of the current directory, so imports like @hypequery/serve resolve from the entry's project. The entry project's .env* files are loaded before the entry runs, so a generated client finds its ClickHouse settings; variables already set in the environment or the launch directory's env files keep precedence. hypequery mcp also loads @hypequery/mcp from that project, so desktop MCP clients can launch npx -y @hypequery/cli mcp /absolute/path/to/analytics/api.ts without changing directory first.

hypequery deploy now prints where the deployment is served: the REST base URL, each dataset's URL, and the MCP URL, as reported by Cloud. --mcp-config also prints MCP client configuration that reads the key from ${HYPEQUERY_API_KEY} and never contains a credential. hypequery mcp --self-test --url <mcp-url> checks a hosted MCP endpoint without calling a tool, reading the key from HYPEQUERY_API_KEY. hypequery mcp --self-test now fails when @hypequery/mcp isn't installed; before, it passed and the real command then failed.

Add hypequery deployment:status to show the selected Cloud target's live release and hosted REST/MCP URLs without redeploying. The command can print MCP client configuration with an environment-variable placeholder and never includes the stored deployment credential.

Refresh production dependencies. Keep the ClickHouse adapter compatible with the client packages' bundled setting types.

Add publishToCloud({ datasets, access }) to declare a validated, dataset-only Cloud deployment without a Serve API. Dataset init now creates analytics/cloud.ts. Named metrics are rejected until Cloud supports their publication explicitly. An authenticated access policy is required, with optional per-dataset overrides, so a migration cannot silently discard Serve role and scope requirements.

The CLI deploy and deployment:build commands now consume that explicit Cloud publication. They no longer compile a Serve API module or bundle Serve runtime handlers. The unused Serve-to-Cloud contract compiler and its compatibility diagnostics are removed. Local Serve and MCP development remain. Existing prebuilt bundles can still be verified and submitted with deployment:validate and deployment:submit.

Build deployment bundles from the canonical deployment contract. hypequery deployment:build writes dataset definitions and derived measures without query entrypoints or runtime artifacts. Named queries and standalone metrics remain local. api.deploymentContract() is the sole contract source, and bundle verification accepts that contract directly. Remove obsolete build flags, JSON output mode, prebuilt deploy --release mode, and customer-handler runtime machinery. Bundle verification requires canonical deployment JSON, and the filesystem store preserves declared source snapshots when persisting a bundle.

Fail a deployment build when the Serve configuration would behave differently under managed execution. Unenforceable tenant isolation and dropped middleware block the build; dropped hooks, dropped context factories, and endpoints that are authenticated without declared roles or scopes are reported as warnings. Pass --allow-unsupported-config to deploy anyway.

Add hypequery mcp, which serves a project's datasets to an MCP client over stdio from the same entrypoint hypequery dev uses, instead of a second MCP config that can drift from it.

--tenant supplies the trusted tenant; the command fails closed when a tenant-scoped dataset is registered without one, since MCP has no request to resolve a tenant from. --self-test checks the entrypoint and exits without speaking the protocol. Application logging is routed to stderr before the entrypoint is imported, because MCP owns stdout.

@hypequery/serve attaches the registered datasets and shared semantic client to the built API under a registered symbol, readable with readServeMcpSource().

Display unsupported configuration diagnostics when deployment explicitly allows them, including the behavior difference and remedy.

Protect generated dataset customizations by refusing implicit overwrites, writing replacements atomically with --force, and adding non-writing --check and --diff modes.

Writes without --force are exclusive creates, so a file written concurrently is refused instead of clobbered. --force replacements preserve the existing file's permissions and never loosen them: the destination's mode is re-read after the replacement is written, and the tighter of the two observations is applied.

Stop dataset scaffolding from automatically enabling tenant isolation based on column-name heuristics. Generated files and CLI output now present every possible tenant key for explicit review instead.

Add generate:datasets --tenant-column <column>, which sets tenantKey on every table that has the column. hypequery init --auth context uses it for the scaffold it generates and prints the matching regeneration command, so refreshing a tenant-scoped project no longer drops tenantKey.

Generate valid TypeScript for pretty-printed ClickHouse types and infer named Tuple(...) values as objects in generated records, query results, and inserts.

DESCRIBE TABLE returns wide types pretty-printed across several lines. Those were embedded in single-quoted string literals, so any table with a multi-line type produced a schema file that did not compile. Type literals are now serialized with JSON.stringify, which escapes newlines and quotes together.

Named tuples are also inferred structurally instead of positionally, matching what ClickHouse actually returns over JSONEachRow. For a column typed Array(Tuple(installed_version String, path Nullable(String))), the record interface the CLI writes changes from:

Potentially breaking for @hypequery/clickhouse. InferClickHouseType previously resolved a named tuple to a positional tuple whose elements were never. Positional reads compiled, because never is assignable to anything, but carried no type information. They are now property accesses:

InsertValue changes the same way, but nothing that typechecked before stops typechecking: its named-tuple elements were also never, so no value could satisfy them. Named-tuple columns previously could not be inserted without a cast, and can now be written as objects:

Object inference assumes the server serializes named tuples as JSON objects (output_format_json_named_tuples_as_objects, on by default). Connections that disable it, or that pin compatibility to a release predating the default, still receive arrays.

Regenerating with the CLI is what surfaces the new record types; existing generated files keep their current shape until you re-run hypequery generate.

Four CLI fixes found while setting up a Next.js project.

Reads .env.local. The CLI loaded only .env, so a Next.js or Vite project with its ClickHouse credentials in .env.local — the convention those frameworks use, and the file the app itself reads — could not connect. Worse, the failure was reported as Unable to detect database type. Re-run with --database, which sends you after the wrong problem entirely. The CLI now reads the same cascade those frameworks do, most specific first: .env.$NODE_ENV.local, .env.local, .env.$NODE_ENV, .env. Earlier files win and real environment variables beat all of them, so existing .env-only setups are unaffected.

Reports the number of tables generated, not discovered. generate --tables ontime against a 79-table database printed Found 79 tables and Generated types for 79 tables while correctly generating exactly one. The filter worked; the message made it look broken. The generator now reports the tables it actually wrote, so duplicate or nonexistent requested names cannot inflate the count. The command says Found 79 tables, applying --tables filter and Generated types for 1 table.

generate:datasets defaults to analytics/datasets.ts. It previously wrote src/datasets/generated.ts while its sibling generate wrote analytics/schema.ts, splitting generated output across two trees. The new default matches the docs, matches generate, and matches findDatasetsFile, which already searched analytics/datasets.ts first. This changes where the command writes when neither --output nor --path is given; pass --output src/datasets/generated.ts to keep the old location.

The "Next steps" example matches the generated file. It was hardcoded to import { datasets } from './datasets/generated' and datasets.orders, regardless of where the file went or which tables were in it. It now uses the real import path and the first real dataset name, so it can be pasted as-is.

Refresh every npm package page with a concise README and complete HypeQuery homepage and repository metadata.

Add live source pull and diff commands plus restore-aware deployment drift protection.

Capture the checked-out Git branch alongside commit and dirty state in deployment source snapshots. Cloud login no longer reads or sends Git branch context; project and environment remain the only deployment-target inputs.

Allow Cloud login to select a stable deployment environment independently of Git branch context.

Send the current Git branch during Cloud login so deployments receive a branch-scoped target. Opt out with --no-branch or HYPEQUERY_CLI_SEND_BRANCH=0. Login now also reports the project and environment Cloud issued the credential for.

Allow trusted in-process hosts to provide an already-authenticated principal to Serve execution, and forward that principal through deployment runtime artifacts while retaining role, scope, and tenant enforcement.

api.execute() (and client() / run()) now accept a trustedAuth option. Supplying it skips credential parsing only; required roles and scopes, tenant extraction, the context factory, validation, middleware, hooks, and cache-control: no-store all still apply. It is unreachable from the HTTP handler, so a network caller cannot set it. Pass null or omit it to fall through to the configured auth strategies.

Because the principal is what authorization ran against, the pipeline now owns ctx.auth and ctx.tenantId. Two behavior changes follow:

• A caller-supplied context containing auth or tenantId is rejected with a VALIDATION_ERROR instead of being merged over the authenticated principal.
• A context factory returning auth no longer replaces the authenticated principal on ctx.auth.

Deployment runtime artifacts refuse a trustedAuth argument when the bundled module exposes no Serve execute() pipeline, rather than running the handler with no enforcement.

Capture, verify, upload, and receive multi-file project source snapshots with deployment bundles, including the API entrypoint and optional Git revision provenance.

Fix two hypequery init defects found while regression-testing the interactive flow.

Ctrl+C now aborts. prompts.override({ onCancel }) was a no-op — override maps question names to pre-supplied answers, not options — so an aborted prompt was indistinguishable from an unanswered one and each caller's ?? default answered on the user's behalf. Pressing Ctrl+C at every prompt still scaffolded a full project and printed "Setup complete!". Prompts now receive a real onCancel handler that raises PromptCancelledError, which the CLI reports as Cancelled. and exits 130.

chDB scaffolding works on the canary channel. Canary builds pin siblings to 0.0.0-canary-*, which cannot satisfy chdb's peerOptional @hypequery/clickhouse@">=2.1.2", so npm aborted the scaffold install with ERESOLVE and hypequery init --database chdb ended with "chdb is not installed". Canary installs on npm now pass --legacy-peer-deps; stable installs and other package managers are unchanged.

Complete the interactive init path with database-driver and authentication choices, skip unused ClickHouse credential questions, and warn before scaffolding outside a directory containing package.json.

Drop the @hypequery/clickhouse dependency from the CLI.

hypequery generate reached into @hypequery/clickhouse/cli for the two functions it needed (generateTypes, clickhouseToTsType), which pulled the entire query builder — roughly 1.1 MB — into every CLI install. The generator now lives in the CLI itself, so npx @hypequery/cli installs neither the query builder nor its module graph.

Nothing changes for users. The query builder is still what the scaffolder installs into your project, and @hypequery/clickhouse/cli plus the hypequery-generate-types bin keep working exactly as before.

Fix ERR_MODULE_NOT_FOUND: Cannot find package '@hypequery/clickhouse' on a clean install.

@hypequery/clickhouse backs hypequery init and hypequery generate, but it was declared as an optional peer dependency while being imported statically. Package managers skipped installing it (pnpm skips peers entirely; npm skips optional ones), so every command — including hypequery --help — crashed before running on a fresh npx @hypequery/cli install. It is now a regular dependency.

Type generators are also loaded on demand, so a failure to resolve one no longer takes down unrelated commands.

Add a one-command deployment workflow that builds, prepares, and submits an API module, while exposing prebuilt uploads through deployment:submit.

hypequery deploy <api-module> now orchestrates build → release → submission, and resolves the Cloud endpoint and token before building so a missing or expired login fails immediately instead of after a full bundle build.

hypequery deploy <bundle> --release <file> still works but is deprecated and now prints a warning. Use hypequery deployment:submit <bundle> --release <file> instead.

Add browser-based Cloud login with PKCE, OS credential-vault storage, logout, and automatic authenticated deployment.

hypequery deploy now also accepts an http://127.0.0.1 or http://localhost submission endpoint for local Cloud development, warning that the token is sent in cleartext; all other endpoints still require HTTPS. HYPEQUERY_API_TOKEN must now be paired with --endpoint or HYPEQUERY_DEPLOYMENT_ENDPOINT — the CLI never combines one explicit value with the other from the stored login profile. A HYPEQUERY_API_TOKEN left in a project .env is picked up by this rule and must be unset to use hypequery login.

Run bundled deployment queries through their Serve execute wrapper so runtime context factories and input/output validation remain active.

Remove the experimental local Studio flag, playground telemetry, and the optional Gateway dependency. hypequery dev continues to provide the development server, API documentation, OpenAPI contract, watch mode, and terminal execution logs.

Clean up the experimental local gateway when dev-server startup fails.

Add anonymous, opt-out usage telemetry to the experimental playground gateway. Telemetry is a no-op until an ingest endpoint is configured, prints a one-time disclosure on first enabled run, and never captures SQL, query names, inputs, results, or paths (machine UUID + hashed project id only; endpoint names hashed, durations bucketed). Opt out with hypequery dev --no-telemetry, HYPEQUERY_TELEMETRY_DISABLED=1, or DO_NOT_TRACK=1; it is also auto-disabled in CI.

Add authenticated, idempotent streaming submission of verified deployment bundles and target-bound releases.

Add deterministic target-bound deployment release envelopes and a CLI command that prepares them only from fully verified deployment bundles.

Add versioned deployment bundle manifests, canonical identities, deterministic bundle directory builds, and strict filesystem verification for deployment and runtime artifact bytes.

Build deterministic Node runtime artifacts automatically when deployment metadata references Serve handlers.

Add canonical deployment contract encoding and domain-separated identities, expose deployment generation on Serve APIs, and add CLI build and validation commands for deployment artifacts.

hypequery init --database chdb scaffolds a project straight onto embedded ClickHouse (chDB) — no server or credentials, and no .env is created or updated. The scaffolded client.ts uses createQueryBuilder({ adapter: chdbAdapter({ session }) }) from chdb/hypequery, chdb is installed as a scaffold dependency instead of relying on CLICKHOUSE_* env vars, and the credential prompts are replaced by a single storage question (in-memory by default, or an on-disk session directory such as ./analytics.chdb via --chdb-path).

hypequery generate --database chdb [--chdb-path <dir>] introspects the embedded session — the type generator's client seam is now satisfiable by a chDB session, so schema types regenerate without an HTTP connection. Persistent sessions are selected explicitly with --chdb-path; in-memory sessions remain process-local and start empty in a later CLI invocation. Dependency-based detection produces an actionable explicit-command hint rather than silently opening an empty session. Dataset scaffolding during init uses the same embedded introspection client instead of falling back to an HTTP ClickHouse connection. chdb stays out of the CLI's own dependencies; it is resolved dynamically from the user's project and a missing install produces an actionable error instead of a resolution failure.

Harden logging and diagnostics without changing public APIs: never mark authenticated or tenant-aware responses as publicly cacheable, log the parameterized SQL template instead of a value-substituted string, and redact connection URLs in CLI output and error messages.

Tighten semantic API type inference, add projection-aware dataset and metric result types, preserve projected rows through React analytics hooks, and add static manifest generation for Next.js clients.

BREAKING (types only, no runtime change): dataset and metric result rows are now projection-typed. DatasetQueryResultFor / MetricResultFor rows — including the output types produced by InferApiType / InferAPIType and the result of createDatasetClient().execute() — no longer expose dimension keys or period unless the query selects them via dimensions / by. Code that read dimension fields off default (non-projected) result types must now pass the projection in the query it executes.

Improve generate:datasets measure heuristics so ID and coordinate columns are emitted as dimensions but not nonsensical sum/avg measures.

Add first-class semantic dataset scaffolding to the CLI.

• hypequery init can now scaffold either the query or dataset workflow, select ClickHouse tables, generate an API entrypoint, and optionally add a context-based authentication scaffold.
• Add hypequery generate:datasets for generating typed dataset definitions from an existing ClickHouse schema, with include/exclude table controls.
• Improve project discovery, generated ClickHouse type handling, prompts, and dependency installation for the new scaffold layouts.

Release @hypequery/clickhouse as 2.0.0 and include the related CLI patch release.

For @hypequery/clickhouse, this release includes:

• a refactor toward an explicit query-node internal model
• stricter withRelation() behavior for chained relationships
• stricter tuple IN validation and improved empty-set filter semantics
• additive groupBy() behavior and improved aggregation inference
• support for ClickHouse-native builder features such as arrayJoin(), leftArrayJoin(), limitBy(), and withTotals()
• exported built-in time-bucketing helpers such as toStartOfMinute() through toStartOfYear()
• url as the preferred ClickHouse connection field, while keeping deprecated host compatibility

For @hypequery/cli, this release includes:

• stricter non-interactive setup behavior with cleaner failure paths
• NodeNext-safe generated scaffold imports
• improved scaffold dependency installation, including zod and aligned canary sibling versions
• support for --skip-connection during init scaffolding

Harden the CLI for release and generated scaffold reliability. This includes:

• stricter non-interactive init behavior, including cleaner failure paths when connection validation fails
• support for --skip-connection during scaffolding
• NodeNext-safe generated relative imports such as ./client.js and ./schema.js
• improved scaffold dependency installation, including zod
• aligned canary scaffold dependency versions when scaffolding from a canary CLI build
• cleaner cancellation and overwrite flows during interactive setup

Fix tuple type inference in generated types from the hypequery generate command to properly render positional tuple types instead of falling back to string. This includes:

• Added helper functions splitTopLevelArgs, unwrapType, and getPrimitiveTsType for better maintainability
• Added support for Tuple(...) types to render as positional TypeScript tuple types
• Added support for LowCardinality wrapper types
• Added support for nested tuple types within Array, Map, and Nullable wrappers
• Added test coverage for tuple type inference scenarios

Update the CLI scaffolding and package guidance to use the current initServe() + query({ ... }) + serve({ queries }) path by default.

• generate analytics/queries.ts templates that destructure { query, serve } from initServe(...)
• scaffold example queries using object-style query({ ... }) definitions instead of the older chained builder-first serve style
• emit an exported api = serve({ queries: { ... } }) shape by default
• align CLI docs and generated comments with the current main-path docs and dev workflow

This makes new projects start on the current serve/query API without needing a separate migration step after scaffolding.

Re-release to ensure CI builds dist artifacts before publishing so the CLI ships with compiled sources.

Enable query execution stats logging in dev server. Removed "Coming soon!" placeholder as the feature is already implemented via serveDev.

Pre-release improvements:

• CLI loading spinners, serve runtime fixes, and React integration updates