# Changelog

What changed in each release, newest first: a section for each, an alpha, a beta or a release candidate as much as
a final release. An alpha (`0.1.0-alpha.1`) is for trying a version early: it may still change before that
version is released. A beta (`0.1.0-beta.1`) is the version complete enough to use before it is released: it may
still change where using it shows a need. Before 1.0, a minor release (0.2.0) may change the policy language, the
`authz.*` functions, the SDKs and the file formats: what to do about it is under **Upgrading**. Each release from
0.1.0-beta.1 on upgrades from the one before it. How releases are numbered and made: [RELEASING.md](https://github.com/rowstile/rowstile/blob/v0.1.0-beta.5/RELEASING.md).

## Unreleased

## 0.1.0-beta.5 (2026-11-18)

### Added

- `authz.login_jwt` takes a token an identity provider signs with its RSA key (RS256), checked in plain SQL
  against the provider's keys. The owner stores them with `authz.set_jwks(jwks)`, the key set as the provider
  serves it, and again when its keys change: a row for each key says whether it was added, replaced, kept, removed,
  or skipped and why; a set that leaves no key is refused and the stored keys stay (AZ719). What a token says of
  itself chooses its check: an HS256 token is checked against `jwt_secret` alone, an RS256 one against the stored
  keys alone, the one its `kid` names. Keys of 2048 to 4096 bits; a check takes about 2 ms at 2048 bits and 7 ms
  at 4096, once for a token on a connection: the same token signing in there again takes 0.3 ms, as an HS256 token
  does. ES256 and EdDSA tokens still go through the backend ([Identity](/reference/identity.md)).
- `rowstile jwks URL` fetches the key set an identity provider serves at `URL` and stores it with
  `authz.set_jwks`, for a scheduled job or a deploy step: run it again when the provider's keys change. It fetches
  over https, from that server alone, 64 KB and ten seconds at most. `--check` stores nothing and exits 1 if the
  stored keys are no longer the provider's; without a URL it lists the stored keys
  ([Tools](/reference/tools.md)).
- A SCIM endpoint for an identity provider's users and groups (Okta, Microsoft Entra ID), answered in SQL:
  `authz.scim(method, path, query, body, token)` takes a request as a route got it and answers a status, a body
  and a location. Groups are read, listed, found by `displayName`, `externalId` or `id`, patched as Microsoft
  Entra ID and Okta write it (members added, removed, replaced), replaced, and made, renamed and deleted through a
  function the app gives. Members are written as `authz.sync_members` writes them, with its line in the audit
  trail. Users are read and found by `userName`, `externalId` or `id`, and made, changed, deactivated and deleted
  through a function the app gives, which gets the user as the request leaves it and never a password. Lists
  answer by pages (`startIndex`, `count`), and `ServiceProviderConfig`, `ResourceTypes` and `Schemas` say what
  is served.
  `authz.set_scim(settings)`, the owner's, names what it reads: the principal whose API key signs the provider
  in, the relation that holds the groups, the columns of its table and of the users', the app's functions; each
  is checked when set (AZ720), and `authz.lint()` says when one no longer holds. A request without that key is
  answered 401, and a refusal is SCIM's error body (AZ721).
  The Python SDK mounts it for FastAPI: `Rowstile(app, engine, ...).mount_scim("/scim/v2")` passes each request
  on and sends the answer back, with the address of what was made (`Location`). The token alone says who asks:
  `user(request)` isn't asked about these requests and their transaction signs nobody in. The body goes on as it
  was sent: the database says when it is no JSON, once the key says who asks, so nothing a stranger sends is an
  error. An error is answered 500 in SCIM's words and logged (the logger `rowstile`). On another framework,
  `rowstile.sqlalchemy.scim()` and `scim_sync()` ask the database the same way. The TypeScript SDK has it
  for Next.js: `export const { GET, POST, PUT, PATCH, DELETE } = scimRoutes({ calls: db.$authz })` in a
  catch-all route (`app/scim/v2/[...scim]/route.ts`) answers the same way, an error logged with
  `console.error`; the address of what was made is on the host the provider asked (`x-forwarded-host`). On
  another framework, `scim(method, path, query, body, token)` of each driver's calls (`db.$authz`,
  `authz(pool)`) asks the database. The other SDKs have no route yet
  ([Identity](/reference/identity.md#users-and-groups-from-an-identity-provider-scim); the setup step by
  step, from apps the tests run: [FastAPI](/stacks/fastapi.md#users-and-groups-from-an-identity-provider-scim),
  [Next.js](/stacks/nextjs.md#users-and-groups-from-an-identity-provider-scim)).

### Changed

- A read through an inherited permission is faster for a reader who isn't an admin of what they read. Where the
  permission starts for the reader is asked in one query, and that query now works out who is signed in and which
  groups they are in once; each relation used to ask for itself, so the docs example worked out a member's teams
  six times for one read. On a GitHub runner (20,000 folders 20 levels deep, the two builds in turn on the one
  machine), an ordinary member opens a file in 2.2 ms where it took 2.8, and a folder in 2.4 ms where it took 3.0:
  a fifth less. An admin's reads, `authz.list` and writes take what they took. Nothing to do: the next `apply`
  or migration writes the functions again.
- A write to a tree (a folder made, moved, linked or deleted, where folders inherit from folders) is faster. The
  functions that keep the stored inheritance take arrays, and Postgres planned each of their statements again on
  every write; they now plan them once for a connection. On GitHub runners (50,000 folders 20 levels deep, the two
  builds in turn on one machine, two rounds, run twice), one client does 236 tree writes a second where it did 177
  to 199, and ten clients 270 to 287 where they did 229 to 241; at fifty clients one run gave a fifth more (229
  against 188) and the other the same (196 against 200). A write of more than a thousand rows still gets plans
  made for it, as a big move needs: one of 17,000 folders takes what it took (0.82 s against 0.79). Nothing to
  do: the next `apply` or migration writes the functions again, and each inheritance is worked out again with
  them (see Upgrading).
- Tree writes to one type no longer wait for each other unless they meet. A write that changes who inherits from
  whom (a folder made, moved, linked, shared into another or deleted) locked its whole type, so writes to
  unrelated parts of a tree queued one behind the other. It now locks what it touches: the rows it changes with
  everything below them, and the rows those hang under. Two writes that meet still wait in READ COMMITTED, and in
  REPEATABLE READ the later one fails with a serialization error only when what it touches changed since its
  snapshot (before: when any tree write to its type had). In SERIALIZABLE a tree write still takes its whole type:
  there Postgres keeps what each transaction read until every one beside it ends, and sixteen writers that didn't
  wait for each other ran the server out of room for it (`out of shared memory`). The trees of one type (a folder's
  inheritance of edit and of view, say) take their locks once for a statement on the type's table. On GitHub
  runners (50,000 folders 20 levels deep, the two builds in turn on one machine), ten clients do 1.5 to 2.3 times
  the tree writes they did, and fifty 1.6 to 2.6 times, writers all in one part of the tree included; one client
  alone does as many, and a write, a move of 14,000 folders and an admin's check while writes run take what they
  took, within what two runs of one build differ by. A write of more than
  1,000 rows takes its whole type, as before, and so does every tree write to a type that inherits through another
  type too or whose inheritance condition reads other rows. The number is a setting: `INSERT INTO authz.settings
  VALUES ('tree_lock_limit', '5000')`, or `'0'` for one tree write at a time to a type
  ([Limits](/reference/limits.md)).
- `@rowstile/next` wants Next.js 16.4.6 or a later 16 (it took 16.4.3): from 16.3.0 to 16.4.4, a `'use cache'`
  function called through `unstable_cache()` could show one root param's data to another (CVE-2026-119790).
  The checks run 16.4.6.
- The Python the npm packages bring is python-build-standalone 20261110's CPython 3.13.18, with zlib 1.4, expat
  2.10.0 and musl 1.2.6 (it was 20261026's).

### Fixed

- A write rule that inherits through a link table asks about the row being written, whatever the link table's
  columns are called (`update : edit` with `can edit = owner or parent.edit` and `parent : doc =
  app.doc_links(child -> parent)`). The rule's check is a function written in SQL that named its parameter `p_id`,
  and in such a function Postgres takes a bare name for a column of a table in scope before it takes it for a
  parameter. So on a link table with a column named `p_id` the check compared every link row with itself: the rule
  could let a write through on a row the user holds nothing on, or refuse one the policy allows. Reads, `authz.can`
  and `authz.explain` were not affected, nor a link table without a column of that name. The functions written in
  SQL that read a table of the app's now write their parameters by position (`$1`), which no column can be: this
  check, the candidates `authz.who` starts from, the functions that work out an inheritance's rows and the sync
  index's keys (where a column named `p_id`, `p_ids` or `p_types` was read in the parameter's place too), and a
  rule's `current_user` (a column named `authz__role` took its place).
  ([GHSA-vr76-9g97-h5p3](https://github.com/rowstile/rowstile/security/advisories/GHSA-vr76-9g97-h5p3))
- A governed table may have a column called `n`, `o`, `x`, `f`, `new` or `old`. Where rowstile hands a row on
  whole, it named the row by its alias alone (`to_jsonb(n)`), and Postgres takes a bare name for a column of a
  table in scope before it takes it for a row. On a table with a column `n` or `o` whose type has a condition
  that names a column, every `UPDATE` failed (`column reference "n" is ambiguous`). With a column `new` or `old`,
  a policy with a rule on a column did not apply. With a column `x`, `authz.explain_rule` on a table with a masked
  column explained a row of NULLs, or failed; with a column `f` or `n`, a mirror of the sync index was not filled
  with the table's rows. A row handed on whole is now written `n.*`, which is the row whatever the columns are
  called.
  ([GHSA-mj6p-w78q-hxf6](https://github.com/rowstile/rowstile/security/advisories/GHSA-mj6p-w78q-hxf6))
- A governed table may have a column named as a generated function names something of its own (`p_id`,
  `p_ids`, `ids`, `n1`, `v_bigint`, `tg_op`). In PL/pgSQL, Postgres refuses a bare name that is both a column of
  a table in scope and a parameter or a variable of the function (`column reference "p_id" is ambiguous`). So on
  a table that merely had a column `p_id`, `authz.share` and `authz.explain` failed; with a column `v_bigint`,
  `authz.can` and `authz.who`; with `n1`, any write the change feed follows; with `p_ids`, a write to a table an
  inheritance follows. Each was an error, never a wrong answer. Where a statement reads the app's tables, a generated
  function now writes a parameter by position (`$1`) and a variable by its block's label (`authz__.v_bigint`),
  which no column can be. And `authz.who` called each candidate `x` inside a query on the users table: on a users
  table with a column `x` it failed, or listed nobody; it calls it `c.id` now.
- A condition may name a column called as PL/pgSQL or rowstile calls something of its own (`found`, `new`, `old`,
  `p_id`): wherever a condition goes, the bare name is the row's column. Where the function that holds the
  condition is written in PL/pgSQL, Postgres refused such a name as ambiguous: a link table whose relation said
  `where {found}` took no insert, and a type's `where`, a permission, a rule or a `shared if` that named such a
  column failed when the policy was applied or when it was asked. Every generated PL/pgSQL function that reads the
  app's columns now says that a column wins there (`#variable_conflict use_column`), its own names being written
  apart (above). Writing `this.found` was the way round, and still works.
- The sync index's mirrors (a preview) are compared with their tables row by row whatever the columns are called.
  On a mirrored table with columns called both `x` and `m`, bringing its mirror up to date (when the policy is
  applied, or the index worked out again) compared two columns of one row in the rows' place: the mirror could
  keep rows as they were, with the readers they had, or be written again whole, and `authz.sync_verify` could say
  a mirror matches when it doesn't. The triggers that keep a mirror as rows change were not concerned.
  ([GHSA-mj6p-w78q-hxf6](https://github.com/rowstile/rowstile/security/advisories/GHSA-mj6p-w78q-hxf6))
- A PowerSync mirror (the sync index, a preview) holds each row as its table has it once a statement is done, also
  when the row was written more than once before the mirror's trigger ran. One statement can write a row twice: a row
  that refers to itself through a foreign key with `ON UPDATE CASCADE`, when its key changes. Such a statement failed
  with `duplicate key value violates unique constraint "<type>__mirror_pkey"`. And a trigger of the app's can write
  the row again: the mirror then kept the row as it was before that write, or, where the trigger deleted the row,
  kept it with no readers, and a row made later with that key failed the same way. The readers of a row were right
  in each case. The mirror's trigger now reads the table again for the keys a statement's rows name.
  `authz.sync_verify()` says false for a mirror left so, and `rowstile reapply --force` writes its rows again.
- `authz.set_role_permissions` lets the caller add a permission they hold on an object the role is given on, even
  where they may not select its row, as `authz.share` lets them give the role there. It asked `authz.can`, which
  answers only for rows the caller may select, and refused: "you cannot give role reviewer on a folder you cannot
  see".
- A policy with a rule on the row after a change (`update status after : ...`) applies to a table with a generated
  column, and the rule reads that column. Applying stopped there on Postgres's own words (`BEFORE trigger's WHEN
  condition cannot reference NEW generated columns`): with a `STORED` column, and on PostgreSQL 18 with any
  `GENERATED ALWAYS AS (...)` column, which is virtual there unless it says `STORED`. On such a table the rule is
  checked once the row is written, after Postgres's own checks on the row; on every other table before the update,
  as it was ([Limits](/reference/limits.md)).
- A key of a `numeric`, a float or a `bytea` column is refused when the policy is compiled (AZ206), as a date or an
  interval is: ids are kept as text, and these write one value several ways. `authz.share(..., 'user', '2.0')`
  found user 2, stored `2.0` and gave them nothing, and the share stayed when their row went, for a later row
  written `2.0`.
- A key whose type isn't one of Postgres's own (an extension's, as `citext`; a domain; an enum) is refused when
  applying (AZ629). It applied, and then every sign-in failed: `type "citext" does not exist`.
- `authz.lint()` reports an app role that may make triggers on a governed table, on a partition of one or on a
  table that holds relationships: the `TRIGGER` privilege, which `GRANT ALL` gives beside `TRUNCATE`, which lint
  already reported. A foreign key's action that writes the table's rows runs such a trigger's function as the
  tables' owner, whom no rule holds. The line says what to take back (`REVOKE TRIGGER ON app.files FROM app_user`).
- `authz.who_among` asks first that who is signed in is to be believed, as every other function does. Called with
  `authz.user_id` changed by hand after a sign-in, or set with nobody signed in, it signed those settings at its
  end, and the transaction went on as that user. It answers AZ702 there now, and AZ701 where nobody signed in.
- The threat model and the identity reference say what a signature holds. They said the app role can't leave
  view-as by setting the settings: a session can put back the settings an earlier sign-in of the same transaction
  signed, with that signature, and is believed. That is a state rowstile signed there, and gives the backend
  nothing `authz.sign_out()` and a sign-in don't; a state no sign-in signed stays an error.
- `authz.revoke_api_key` in a session limited by scopes (a key's, a token's) revokes only a key no wider than the
  session: one that has scopes, each of them the session's, as `authz.create_api_key` holds a new key to. A key
  whose scope holds a write command could revoke its user's other keys, one with every scope too. It answers
  AZ704 there now.
  ([GHSA-xxg2-j2vj-v993](https://github.com/rowstile/rowstile/security/advisories/GHSA-xxg2-j2vj-v993))
- A table that inherits (`CREATE TABLE ... INHERITS`) with a generated column of its own gets its copy of a rule
  on the row after a change made after the update, by its own columns. Where the table above had no such column,
  the next migration, or `rowstile apply`, stopped there on Postgres's own words.
- `authz.lint()` says two more things, as infos: an app role that may make foreign keys to a governed table or to
  a partition of one (`REFERENCES`, which `GRANT ALL` gives: a foreign key tells whether the row it names is
  there, whoever may see it), and a table whose rule on the row after a change is checked once the row is written
  (it has a generated column), where a unique index or a foreign key of the table speaks first.
- A text key compared by a collation that isn't deterministic (a case-insensitive one) is refused when applying
  (AZ630): two texts are one key there, and two ids to rowstile, as `2` and `2.0` were.
- `authz.share` and `authz.unshare` read a subject relation given as NULL as none, as `''` is. The share failed
  on Postgres's own words (a column that takes no NULL), and the unshare removed nothing.
- A condition that limits inheritance, or that the sync index reads, is refused when it calls the clock or reads
  the session by a name written in quotes too (`pg_catalog."now"()`), where the condition reads another table
  and Postgres isn't asked (AZ305, AZ804, AZ805).
- `authz.view_as` in a session limited by scopes that hold a write command (a key's or a token's: `update`,
  `app.files.update`) is read-only, as it says: the rules now refuse every write while a session views as someone,
  whatever its scopes hold. Since 0.1.0-beta.2 such a session kept its scopes while viewing, and the rules asked the
  scopes alone, so it could change rows as the user it viewed as. A session signed in with `authz.act_as` was not
  affected. A rule's explanation says so (`no   the session views as someone else: it may not update on app.files`).
  ([GHSA-47r9-v6p6-mc95](https://github.com/rowstile/rowstile/security/advisories/GHSA-47r9-v6p6-mc95))
- A condition that calls the app's code without its text showing the call ran it with the app role's rights where a
  rule is checked: a function of the row written as a column of it (`{this.blocked}` for `blocked(docs)`, a computed
  column), a cast to a type of the app's, `OPERATOR(app.=)`. Such a function read of a table with rules only what
  the signed-in user may see, so `not {this.blocked}` let through rows `authz.can` refused. Applying now asks
  Postgres what the rules and the views they read call, and refuses a function of the app's there that may read
  data (AZ628), and so does every migration. A call written by its name with parentheses runs with the policy's
  rights, as before.
  ([GHSA-62w9-42x3-hqcm](https://github.com/rowstile/rowstile/security/advisories/GHSA-62w9-42x3-hqcm))
- On PostgreSQL 16.16, 17.12 and 18.7 (released on 2026-11-12), an app's migration could no longer add a column
  `NOT NULL` with a default, add a stored generated column, or change a column's type, on a table with rules on
  writes or on a column: `cannot alter table "files" because function authz_gen."app.files:insert:items"(app.files)
  uses its row type`. Those releases refuse it where a function's body kept parsed (`BEGIN ATOMIC`) or a trigger's
  `WHEN` holds a value of the table's row type (CVE-2026-6460). The functions that check a rule on a row are now
  bodies Postgres keeps no parse of, run as the policy's owner, reading only that row, and the triggers hand them
  the row as JSON. A condition's `current_user` there is still the role that writes.
- The Go SDK asks for `golang.org/x/text` v0.41.0 or newer, which fixes an infinite loop and a panic on crafted
  input (GO-2026-5970, GO-2026-6629). The Elixir SDK is checked against Ecto 3.14.3, which bounds a query cache that
  could grow without end (EEF-CVE-2026-118391).

### Upgrading

- Apply the policy with this release (`rowstile apply`, or the migrations `rowstile migrate` writes) for tree
  writes to lock what they touch: each inheritance is worked out again, and `rowstile migrate` writes two
  migrations, one that builds the new tables beside the ones in use and one that swaps them in. A write that runs
  while the policy is applied ends with AZ723 (`40001`), to retry. An app that writes a tree in transactions of
  several statements, or with one statement that writes several trees (a cascade to rows that are links, `MERGE`,
  `INSERT ... ON CONFLICT DO UPDATE`), may now see a deadlock (`40P01`) where two such transactions meet: retry
  it, as `40001` ([Retrying a write](/operations.md#retrying-a-write)).
- A table the policy names can't have a name that starts with `authz__` (AZ113): the functions rowstile writes
  call their own variables `authz__.name`. Name a view of the table instead.
- Apply the policy with this release (`rowstile apply`, or the migrations `rowstile migrate` writes) for the fix
  to the write rules that inherit through a link table. The functions that work out an inheritance's rows changed
  with it, so each inheritance is worked out again: `rowstile migrate` writes two migrations, one that builds the
  new tables beside the ones in use and one that swaps them in. Until then, a link table a policy names should have
  no column called `p_id`.
- A policy with a type keyed by a `numeric`, a float or a `bytea` column no longer compiles (AZ206): key the type
  by a column of integers, text or uuid.
- `authz.who_among` in a transaction where nobody signed in now answers AZ701, as any other question does: sign
  in first, as nobody where no one is asking (`authz.act_as(NULL, NULL)`; the SDKs' transactions do).
- `authz.lint()` has a new error where the app role holds `TRIGGER` on a table the policy governs (an app set up
  with `GRANT ALL`): `rowstile lint` then exits 1 until it is taken back.
- A session limited by scopes no longer revokes a key with other scopes, or with none (AZ704): revoke keys from
  a session without scopes, as the app's own sign-in is.
- A policy with a type keyed by a text column under a collation that isn't deterministic no longer applies
  (AZ630): key the type by a column under a deterministic collation.
- A policy whose condition reads a function of the row as a column, where the function isn't IMMUTABLE, no longer
  applies (AZ628): call it by its name on the row's columns, `{app.blocked_doc(this.id)}`, or mark it IMMUTABLE if
  it reads nothing.
- On Postgres 16.16, 17.12 or 18.7, or before upgrading to them, apply the policy with this release (`rowstile
  apply`, or the migration `rowstile migrate` writes): what an earlier release applied stops the migrations above
  there.

## 0.1.0-beta.4 (2026-11-09)

### Added

- The Go module has versions: each release tags its commit `sdk/go/vX.Y.Z`, so `go get
  github.com/rowstile/rowstile/sdk/go` takes the newest release's, and `@vX.Y.Z` names one ([Go](/stacks/go.md)).
- `rowstile client ts-sdk`: the policy's names alone, registered with the TypeScript SDK, asked for by name. It is
  what `[clients] ts` writes in an app on the SDK; `rowstile client ts` is the client for `pg` without it.
- `authz.sign_out()`: nobody is signed in in the transaction afterwards, and it may sign in again, as anyone. It
  is for a test's transaction that acts for one person, then another, and is rolled back at the end; the SDKs'
  test modes call it ([Identity](/reference/identity.md)).
- The Go, Rust and PHP SDKs write a principal as text and read it back, as the other SDKs do and as the audit trail
  names who acted (`42`, `service:3`, `nobody`): `String` and `rowstile.ParsePrincipal` in Go, `Display` and
  `FromStr` in Rust, `__toString` and `Principal::parse` in PHP. In Laravel's logs a principal reads `service:3`.
- The Spring starter's `Problems.problem(e)` and `Problems.response(problem)`: rowstile's answer to an error, for a
  catch-all `@ExceptionHandler(Exception.class)` of the app's own, which comes before the starter's advice and would
  take its errors too ([Spring](/stacks/spring.md)).
- The Rust SDK's `rowstile::axum::SignedIn`: an extractor for who a request acts for, with no connection yet, for a
  handler that reads a body; `who.begin()` begins its transaction once the body is read. A `Tx` holds a connection,
  its transaction open, from the moment Axum extracts it, and Axum reads the body last.
- The helpdesk, a third example app ([examples/helpdesk](/examples/helpdesk.md)): several companies' support
  desks on one database, each company's workspace kept apart by the policy, with teams inside teams, custom roles,
  internal notes, the vendor's staff by break glass, and live updates through Electric. Next.js, Prisma and the
  TypeScript SDK.

### Changed

- The database holds a transaction to one principal: `authz.act_as`, `authz.login_key` and `authz.login_jwt`
  refuse to sign in a transaction signed in as someone else already (nobody included), or one that views as
  someone or is limited by scopes, which a new sign-in would end (AZ716). A first sign-in after
  `act_as(NULL, NULL)` is still fine, and so is the same principal again. `view_as`, and `who`, `explain`,
  `who_among` and the invariants, which ask as others and put back the caller, aren't held to it, nor are the
  sessions of the policy's owner and superusers.
- The Rust SDK's `rowstile::testing::per_binary` refuses an app role's URL that isn't a Postgres URL, instead of
  giving it back as it was.
- The Rust SDK's `per_binary` gives each slot of cargo-nextest (`NEXTEST_TEST_GLOBAL_SLOT`) a copy of its own, as
  each binary has under `cargo test`.
- Seeing who has access to an object (`authz.who`, `authz.list_shares`, `authz.list_links`, `authz.explain` for
  someone else, `authz.start_review`) takes `share` on a row the user may select, and `authz.who_among` lists those
  for whom `authz.can` says yes (below). What acts on an object still asks the permission itself: sharing, roles,
  API keys, `authz.view_as` and `authz.break_glass`, which works on a row the user can't see. So do `authz.who`'s
  answers, the first line of `authz.explain`, `rowstile why` and a test's `user X can PERM TYPE ID`. The access
  previews (`rowstile diff`, the review's access, `rowstile dev`, `rowstile snapshot`) still list every permission
  gained or lost, on rows the user can't select too.
- `rowstile review` and `rowstile prove` work out what their small worlds read of a policy once, not in each
  world, and prove makes each world once for all the invariants: on the docs app's policy, reviewing a refactor
  takes a third less time, and proving four invariants a quarter of the time it did.
- `rowstile init` with `--db` and another `DATABASE_URL` writes `database = "env:ROWSTILE_OWNER_DSN"` in
  `rowstile.toml`, the name the stack pages give the tables' owner's connection, instead of
  `ROWSTILE_DATABASE_URL`. Its next steps name the variable `rowstile.toml` reads, not always `DATABASE_URL`.
- `authz.review_decide` refuses a decision after the review's deadline, the `closes_at` of `authz.start_review`
  (two weeks after it starts unless the call says otherwise; NULL: none), and says when it was (AZ718).
  `authz.close_review` still applies the decisions made in time. Before, the deadline was kept and never read.
- A page with a cursor and no size is every row after the cursor in every SDK: Go's `Page{After: x}` (a `Limit` of
  0) no longer asks for an empty page, and the Rust SDK's `Page.limit` is an `Option<i32>` (`None`: no size). The
  Rust SDK's `composite_key` of one field is that field's value, as a key of one column is.
- The Go SDK's `Middleware` answers 401 for `rowstile.Unauthorized(detail)` (new), the error the app's `user`
  function gives for a bad token, and answers any other error from it as `Handler` does: rowstile's own as its
  page says, anything else logged and a 500, without its words. Before, every error was a 401 that showed the
  error's text, so a session store that was down signed everyone out.
- The Python SDK's `rowstile.fastapi` loads SQLAlchemy only for an engine: an app on psycopg or asyncpg alone,
  `Rowstile(app, None, user=...)`, runs without SQLAlchemy installed.
- The Python SDK's `assert_refused(fn, command=...)` asks for the rule by its whole name: `command="up"` fails for
  a refusal of the update rule, where it passed.
- `authzRoutes()` (`@rowstile/next`) answers 400 to a request that names no type, and to a body that isn't a JSON
  object, instead of an error, a 500.
- In the TypeScript SDK, a transaction begun inside another for the same principal (`transaction(fn)` in
  `@rowstile/pg` and `@rowstile/drizzle`, `begin(fn)` in `@rowstile/postgres`) is a savepoint of it, on its
  connection, as in the Python and Go SDKs: it sees what the outer one wrote, and one that fails is rolled back to its
  savepoint. Before, it took another connection, and on a pool of one it waited forever. Through Prisma,
  `db.$authz` (and `tx.$authz`) inside `$transaction(async (tx) => ...)` asks in that transaction, as the other
  packages' calls do in theirs; before, it asked on another connection.
- The .NET SDK's helpers its EF Core package alone calls are no longer public: `Keys`, `Verdicts`, `RowAsked`,
  `RowAnswer`, `RowstileNpgsql.ActAs`, `ActAsArgs`, `ActAsParameters` and `AskAsync`, and `Stale.Record`. Its README
  lists what is ([.NET](/sdk/dotnet.md)).
- The Ruby SDK needs Active Record 8.1 (`~> 8.1`), the version its suite runs: it hooks into parts of Active Record
  that change between minor releases, and it was never run on 8.0.
- The Ruby SDK's `assert_refused(command:)` asks for the rule's whole word (`select`, `insert`, `update` or
  `delete`), as the Kotlin and Elixir SDKs do. Before, the beginning of one passed (`"up"`, or `""`).
- The Rust SDK's `SignIn::principal` is async and takes the request's parts mutably, so it can look a session up
  in a database, fetch a key set, or run another extractor on the request: an app's impl writes
  `async fn principal(&self, request: &mut Parts) -> Result<Principal, Error>`.
- The Elixir SDK's `Rowstile.Testing.assert_refused(result, command)` takes the rule's whole name (`insert`,
  `update`, `delete`, `select`): a part of it, such as `"up"`, or `""`, fails the test. Before, any start of the
  name passed.
- The PHP SDK's `assertRefused($fn, $command)` asks for the rule's command itself (`select`, `insert`, `update` or
  `delete`). Before, any start of it passed: `'ins'`, and `''` for any refusal.
- The PHP SDK's `php artisan rowstile:check` refuses a connection that signs no transaction in: a pgsql connection
  another package's class made instead of rowstile's. `Rowstile\Laravel\SignsIn` is the trait that signs them in,
  for a class of the app's that extends that package's.
- In a Laravel app, a model whose update or delete changed no row is asked about in the transaction the statement
  ran in, one of its own when none is open. Before, outside `DB::transaction`, the question ran in a second
  transaction, and its answer was about the row as it was then.
- The PHP SDK's `permitted` compares a uuid key (a model with `HasUuids`) as uuid, so its index is used. Before, it
  cast the column to text, and the query read the whole table.
- The VS Code extension (0.1.5) works in Restricted Mode: `.authz` files are highlighted there, and the language
  server starts once the folder is trusted (it runs the program `rowstile.command` names). The extension was
  turned off there, its highlighting too.
- The playground serves Pyodide and PGlite from its own site, at the versions its `package.json` pins, instead of
  loading them from jsDelivr. Mermaid still comes from jsDelivr, checked against its hash as Studio checks it, and
  the page's Content-Security-Policy lets scripts run from the site and that file alone.
- The npm package's launcher exits 2 when it can't run the command (no Python to run on, a `ROWSTILE_PYTHON` that
  isn't one, a path too long for Windows), as the command's own exit codes say of what it couldn't do; it exited 1.

### Removed

- `rowstile review --json`: `access.users_in_data`, which was always null.

### Fixed

- The VS Code extension (0.1.5) sends the language server files only, and new ones not saved yet. The left side of
  a diff has the file's path, and while it was open the test files were checked against the policy as committed,
  not as typed. The language server keeps to the file too when another editor sends such a view of it.
- VS Code leaves a relation named with a block's first word (`scope : user shared`) where it is typed. It moved it
  back to the margin, where the compiler refused it.
- `rowstile init --role` refuses a name the policy's app role line can't hold (a space, a quote), before connecting.
  Before, it wrote a draft that didn't compile and a `CREATE ROLE` for another name.
- `rowstile init` without `--schema` leaves out the sync index's schema, `authz_sync`: its tables were drafted as
  the app's, and the roles granted them counted when it chose the app role.
- `rowstile init` reads `pyproject.toml` as TOML: its dependencies, optional ones, dependency groups and Poetry's
  tables. Before, each line's first word counted as a package, so any `pyproject.toml` made the app a Python one.
  It reads Alembic's `script_location` as Alembic does (`%(here)s` without a slash, a folder written with `\`), and
  for a package's (`myapp:migrations`) leaves `[migrations]` out, saying why. The paths it writes in
  `rowstile.toml` are TOML strings, so a quote or a backslash in one no longer makes the file unreadable.
- `rowstile client LANG` with no file is of the policy `rowstile.toml` names, as `rowstile graph` is and the reference
  says, with no database (but `powersync`, which reads the database `rowstile.toml` names); before, it connected and
  wrote the client of the policy in force. A language it doesn't write, or none with no `[clients]`, is refused
  before connecting. With no language, it says of each file that it wrote it or that it was up to date.
- `[clients] ts` is the names alone when the package.json nearest the client's file depends on `@rowstile/*`
  (`frontend/package.json` for `frontend/src/authz.ts`), looked for up to the git repository's top. Before, the one
  in `rowstile.toml`'s folder decided, or one above it, even above the repository. A package.json with a byte order
  mark is read.
- `rowstile client powersync`, a preview: a table the policy mirrors and the database doesn't yet is said, with
  what to do (apply or push first), instead of a traceback. Each stream's alias, the table's name on the client, is
  quoted, so a table named with a keyword (`app.order`) gives a stream the service takes. Two mirrored tables of
  one name in two schemas, which a client would name alike, are refused (AZ811).
- `rowstile graph` draws the user type's own relations: an arrow through one (`owner.manager`) pointed at a box the
  diagram didn't have.
- `rowstile client go`, `csharp`, `ruby`, `rbs` and `elixir` give no name to a type or a permission whose name there
  would be one the file or the SDK uses already, as for two names spelled the same: Go's `ObjectType` (object's
  `type`), C#'s classes `Permission` and `ObjectType` (which hid the SDK's) and the names of object's own members
  (`ToString`, `GetHashCode`, `GetType`, `Equals`: a class hid them), Ruby's modules `Rowstile`, `Hash`, `Array`
  and `String`, and Elixir's `Rowstile` and `Kernel`. Before, the file didn't compile. `rowstile client
  zero` names the readers tables of two types camelCase spells the same (`a_b`, `aB`) as each type is written.
- `authz.ctx(key)` is NULL for a key the transaction didn't set, also on a connection where an earlier
  transaction set it (Postgres then reads it as `''`), and for a key set to `''`: a condition or a caveat that
  reads the request context answers the same on a pooled connection as on a new one.
  ([GHSA-q9m7-hm63-2wmc](https://github.com/rowstile/rowstile/security/advisories/GHSA-q9m7-hm63-2wmc))
- `rowstile lsp` sends, when it reads the table and column names, the password in `rowstile.toml`'s database
  string or `PGPASSWORD` in `.env` beside it, not the editor's own `PGPASSWORD`: the folder opened names the host.
  ([GHSA-7pm7-3h78-3vv7](https://github.com/rowstile/rowstile/security/advisories/GHSA-7pm7-3h78-3vv7))
- `rowstile lsp`: in a test file with a mistake, hover, go to definition and find references still answer on its
  other lines. An included file's outline is its own types, not the policy's. Find references reads a `--` inside
  a condition's string as text, and completion offers a condition's columns on its later lines too. After
  `shutdown` a request is refused, and `exit` without `shutdown` ends the server with status 1, as the protocol
  says.
- `rowstile mcp`: `why` refuses an id the command would read as an option (`-h` printed its help; a negative number
  is still an id), and `test` refuses a `coverage` that isn't true or false (the text `"false"` turned it on). A
  call stopped after 600 seconds keeps what the command printed before it, so the agent sees where it was.
- The sync index, a preview: a PowerSync mirror (`mirrored`) is made again when the policy masks a column of its
  table since, so the masked column leaves the mirror and the sync engine's role can't read it; `authz.sync_verify()`
  says false, and `authz.lint()` reports an error, while a mirror holds a masked column.
  ([GHSA-42v7-x658-h6vv](https://github.com/rowstile/rowstile/security/advisories/GHSA-42v7-x658-h6vv))
- The sync index, a preview: `rowstile apply` changes a PowerSync mirror in place when its table's columns changed
  since (a column added, dropped, or of another type), so the `powersync` publication keeps it; before, apply said
  `unchanged`, and `rowstile reapply` made the mirror again out of the publication. `authz.lint()` warns of such a
  mirror. Apply also makes again a mirror, or the table of what waits after commit, that was dropped since (the
  table's writes failed until then), and warns of each publication a readers table made again (its type's key
  changed) is no longer in.
- The sync index, a preview: a `TRUNCATE` of one partition of a mirrored table, or of a table that inherits from
  it, takes the rows stored there out of the PowerSync mirror, and the index works out the type's readers again.
  Before, the mirror kept them, and PowerSync kept syncing rows the app had deleted.
- The sync index, a preview: in READ COMMITTED, writers whose work meets no longer end in a deadlock (40P01) at
  commit. Three writers could: two waiting for a third, then each reaching what the other held once it committed.
  A lock row the work needs below one it holds is now taken only if nobody holds it; else the work lets go of them
  all and takes them again in order.
- The sync index, a preview: applying refuses a superuser as the sync role saying so (AZ808), not that it is a
  member of the role applying the policy; `authz.lint()` reports a sync role made a superuser since once, not as
  a member of the app role that owns every governed table. Lint still reports another role's privileges on
  `authz_sync` while the sync role is gone (renamed or dropped since).
- A condition that calls a function by its three-part name (`mydb.app.f(id)`), or a function named `filter`,
  `within`, `over` or `is`, is read as calling the app's code, as one written `app.f(id)` is: it runs with the
  policy's rights wherever it is checked, the change feed watches every column of its row, and the sync index
  refuses it (AZ806).
  ([GHSA-m547-pwr6-2vfx](https://github.com/rowstile/rowstile/security/advisories/GHSA-m547-pwr6-2vfx))
- A condition that limits inheritance can't read who asks or the session through `pg_has_role()`,
  `has_table_privilege()` and the other `has_*_privilege()`, `row_security_active()`, `inet_client_addr()` and
  the other `inet_*` functions, `current_schemas()`, `pg_my_temp_schema()`, `pg_trigger_depth()`, `nextval()`,
  `currval()` or `lastval()`: compiling refuses it (AZ305), in a condition that reads another table too, where
  applying can't ask Postgres. A synced permission that reads them is refused (AZ805).
- `[review] snapshot`, the `[clients]` paths and `[migrations] dir` in `rowstile.toml` stay in the git repository
  it is in (the first folder up with a `.git`), or in its folder when it is in none: `rowstile snapshot` (with or
  without `--check`), `rowstile client`, `rowstile dev` and `rowstile migrate` refuse a path outside it, or a link
  out of it, and name it (exit 2). A monorepo's `../frontend/src/authz.ts` still works. `--out` and `--dir` are
  still the caller's.
  ([GHSA-c27j-v832-rfwh](https://github.com/rowstile/rowstile/security/advisories/GHSA-c27j-v832-rfwh))
- Each view the compiler makes for a relation or a permission has a name of its own: a relation's view of its
  sources other than columns is now `doc__r:ext`, apart from the view of an arrow to a permission named `ext`
  (`r.ext`, `doc__r__ext`), and an arrow followed to some of its types joins them with `__` (`__on_a__b`). The
  compiler fails rather than give one name to two views.
  ([GHSA-8wgc-xvw3-m3gm](https://github.com/rowstile/rowstile/security/advisories/GHSA-8wgc-xvw3-m3gm))
- The sync index, a preview: a share that starts or ends while a writer's transaction is open is worked out again
  by the first `authz.sync_tick()` after that transaction commits, even when a tick ran meanwhile. Before, the index
  kept what the writer worked out (a reader whose share had ended, or none for one that had begun) until something
  else changed that object. The index keeps each object's next share start or end in `authz_sync.due`; applying
  works the index out once again to fill it.
  ([GHSA-r9mx-55hw-gf9q](https://github.com/rowstile/rowstile/security/advisories/GHSA-r9mx-55hw-gf9q))
- A caveat that calls a function or an operator of the app's runs with the policy's rights wherever its share
  is checked, as a condition does: a select on the table and its masked view say what `authz.can` and
  `authz.list` say.
  ([GHSA-wf6p-c49j-575h](https://github.com/rowstile/rowstile/security/advisories/GHSA-wf6p-c49j-575h))
- The Elixir SDK: `Rowstile.transact` inside a transaction it didn't begin (a `Repo.transaction` of the app's, a
  Postgrex transaction's connection) raises a `RuntimeError` before anything is sent, as the Python and PHP SDKs
  do, instead of signing that transaction in. `Rowstile.acting_as` says, in its docs, that inside a `transact` the
  statements still run as that transaction's principal.
  ([GHSA-x4hg-m454-w962](https://github.com/rowstile/rowstile/security/advisories/GHSA-x4hg-m454-w962))
- The Go SDK: `rowstile.LoginKey(ctx, tx, key)` and `rowstile.LoginJWT` sign a request in with an API key or a
  token inside `Tx`, and `Tx` follows whom the transaction is signed in as from then on: a nested `Tx` for the
  key's principal is a savepoint, and anyone else's is refused. A login made with SQL inside `Tx` left `Tx`
  answering for the principal it began with ([Go](/stacks/go.md)).
- The .NET SDK: an EF Core context on a connection where `BeginSignedInAsync` began a transaction, not brought to
  it with `UseTransaction`, no longer signs that transaction in again as whoever the code acts for (Npgsql runs the
  context's commands in it). Its work runs there as it is while the code acts for the transaction's principal, and
  is refused for anyone else with an `InvalidOperationException`, before anything is sent. In a `TransactionScope`
  the connection takes part in, the context's work is refused, as that transaction's sign-in can't be known
  ([ASP.NET Core and EF Core](/stacks/aspnetcore.md)).
  ([GHSA-x4hg-m454-w962](https://github.com/rowstile/rowstile/security/advisories/GHSA-x4hg-m454-w962))
- Every SDK's test helper keeps the copy's name within Postgres's 63 bytes: a longer one is shortened to its first
  54 bytes (fewer, not to cut a character in two), `_`, and the first 8 hex digits of the SHA-256 of the whole name.
  Postgres cut it before, so a long name could stand for the original, which the helper then dropped, or for
  another worker's copy.
- The Go SDK's `rowstiletest.PerPackage` says so of a URL that doesn't parse, the app role's too, instead of
  failing on it or leaving the app role's URL out.
- The Rust SDK's `per_binary` names the copy in an app role's URL that names no database, and reads a name the URL
  percent-encodes; the Java SDK's `WorkerDatabase.copy` reads it too, and writes the copy's so.
- The Elixir SDK's `database_per_partition` connects with SSL when the URL's `sslmode` asks for it, and the PHP
  SDK's `Databases` pass the URL's settings (`?sslmode=require`) to libpq.
- The Python SDK's `database_per_worker` keeps a URL whose host is in its settings (`postgresql:///app?host=...`)
  as it is written.
- The change feed is in the order of transactions: `authz.changes_since(pos)` gives the entries after the one at
  `pos`, and only those of transactions older than every one still open, so a reader that goes on from the last
  entry it read hears of every entry, even one whose transaction ended after a later one's. The newest entries show
  up once the transactions before them end. `authz.changes_position()` says where the feed is, for a reader that
  starts; a position no entry has gets AZ712, as one trimmed does. `authz.trim_changes()` removes the oldest
  entries in that order.
  ([GHSA-v7cp-x44m-qfg2](https://github.com/rowstile/rowstile/security/advisories/GHSA-v7cp-x44m-qfg2))
- `rowstile apply` computes an inheritance table again, instead of keeping it, when its table or link table has
  other tables under it than at the last apply: a partition attached, detached, made or dropped, or a table that
  inherits made or dropped. The rows such a change brings or takes away, which no trigger saw, are then in the
  table, and an apply of the same policy no longer answers `unchanged` after a partition is detached. The
  migrations `rowstile migrate` writes do the same for each inheritance table they keep.
  ([GHSA-84mf-ch68-55hg](https://github.com/rowstile/rowstile/security/advisories/GHSA-84mf-ch68-55hg))
- `authz.explain` for another user (its fourth argument) says only what the one asking may see: its walk stops at an
  object or a team they can't see, as it does when they ask for themselves, and a share's maker, end, start and
  caveat show only where they may list that object's shares (`authz.list_shares`). It says `shared with them` and
  `they are member there` of that user, not `you`.
  ([GHSA-rq22-3c72-68vg](https://github.com/rowstile/rowstile/security/advisories/GHSA-rq22-3c72-68vg))
- `authz.set_role_permissions` refuses to add a permission the caller doesn't hold on each object the role is given
  on, as `authz.share` refuses to give the role there (AZ705): "you cannot give role reviewer on folder 2: you do
  not hold archive", or "on a folder you cannot see" for one they can't see. Taking a permission out still needs
  only `manage_roles`, and a role given to nobody may still be changed freely. A share of the role made meanwhile
  waits for the change, and weighs what the role gives then.
  ([GHSA-34jx-5ch8-mgqw](https://github.com/rowstile/rowstile/security/advisories/GHSA-34jx-5ch8-mgqw))
- `authz.break_glass` refuses, naming the share (AZ717), when the caller holds a share of that relation that starts
  later or holds only while a caveat does, instead of replacing it with one that held from now, without the caveat,
  until that share's end. The emergency access ends when its time does; a share that lets the caller in now is left
  as it is.
  ([GHSA-c9xj-8fcj-qvgr](https://github.com/rowstile/rowstile/security/advisories/GHSA-c9xj-8fcj-qvgr))
- Each migration `rowstile migrate` writes turns row-level security on for the partitions of each table with
  rules, and the tables that inherit from one, as each apply does: a partition made or attached since is read
  and written through its table from then on, also when the migration doesn't change that table's rules.
  ([GHSA-fgwq-mp37-w8mf](https://github.com/rowstile/rowstile/security/advisories/GHSA-fgwq-mp37-w8mf))
- `TRUNCATE ONLY` on a type's table that other tables inherit from keeps the shares, API keys and pending access
  requests of the rows stored in those tables. Before, it removed them all, as emptying the whole table does.
- `TRUNCATE` run directly on a partition of a watched table, or on a table that inherits from one, removes the
  shares, API keys and pending access requests of the rows it empties, and rebuilds the inheritance trees they
  are in. Before, it ran none of those triggers: the shares stayed until the next apply, a row made later with one
  of the ids got them, and a tree kept rows under a parent that was gone.
- `authz.lint()` counts a privilege on one column as it counts one on the table: it reports a membership table
  without rules that the app role may insert into or update one column of, a partition it may use that way, a
  view that runs with its owner's rights of which it may read one column, and the notes that go with them.
  `authz.connection_check()` reports a login that is a member of a table's owner without inheriting its rights:
  it may `SET ROLE` to the owner.
- `authz.lint()` counts a privilege on one column as it counts one on the table: it reports a membership table
  without rules that the app role may insert into or update one column of, a partition it may use that way, a
  view that runs with its owner's rights of which it may read one column, and the notes that go with them.
  `authz.connection_check()` reports a login that is a member of a table's owner without inheriting its rights:
  it may `SET ROLE` to the owner. It also reports a login that switched to the app role with `SET ROLE` and owns a
  table with rules, or is a member of its owner: `RESET ROLE` leaves the rules.
- `rowstile fmt` lays out a file that starts with a byte order mark as any other, and leaves the mark out. Before,
  it didn't line up the relations and permissions of the file's first block.
- `rowstile test` runs a test whose name, or an id in quotes on one of its lines, holds a dollar quote's tag such
  as `$authz_tests$`. Before, the tag ended the function the tests are compiled into, and Postgres gave a syntax
  error that named nothing of the policy.
- A test's id in quotes is the text in them, `$` or not: `user 1 can view file '$x'` asks about the file whose id is
  `$x`, where `'$x'` was read as the name `$x`; and `a$b` is that text, where it was refused as naming `$b`. An id
  without quotes that starts with `$` and is no name (`$x$`) is refused with its line (AZ106), where compiling the
  tests failed with a Python error.
- A `$name` in a string or a comment of a test's SQL is text: `given {INSERT ... VALUES (9001, 'Ann $smith')}`
  was refused ("$smith is not named yet", AZ501), or had the name's value put inside the string.
- A test file holding a `sync` line, a masked view (`rules app.files view ...`) or a `cascade from` line is
  refused (AZ106), as one holding a type is: a test file holds only named tests. Before, those lines did
  nothing, and nothing said so.
- A string, a quoted name or a dollar quote in a named test's statement (`given {...}`, `as ... {...}`) that goes
  over several lines holds them as written: its line breaks, its spaces and a `--` in it. Before, its lines were
  joined by a space. `rowstile fmt` leaves those lines as written. In a condition elsewhere, such a quote is
  refused with its line (AZ114), where its text was changed the same way.
- An included file that is there and can't be read says why, in the editor and in the suites' compiler as in
  `rowstile check`: it isn't UTF-8, say. Before, the editor and `compile_policy.py` said they couldn't find it.
  `parse_policy` called with neither a path nor the files reads no included file from the current folder.
- A mistake in an included file whose name has a space (`include "my roles.authz"`) is shown where it is: on that
  file and its words in the editor, with its line in `rowstile dev`, with its file and line in the MCP server's
  `check`, in the review and in the playground. Before, the editor put it on the policy's first line, and the
  others lost its place.
- `rowstile apply` remakes a trigger the policy made that is gone when a write rule's condition reads a column named
  `begin`, instead of saying `unchanged`: reading the compiled SQL back, a `begin` in parentheses no longer opens a
  block, as psql reads it. Migrations for Drizzle Kit keep one statement between breakpoints there too.
- A migration that removes an inheritance tree drops the tree's index by its schema (`authz_int`), not by its
  name alone on the search path, where an index of the app's with that name would have gone instead. The lock
  file names those indexes with their schema from the next migration on; one written before needs no migration.
- A migration of a policy whose text ends in `$authz_policy` (a comment, with no newline after it) runs: the quote it
  records the text in no longer ends early.
- `authz.create_api_key` and `authz.list_api_keys` refuse a principal type given without its id (AZ710), instead of
  taking it for the caller's own keys, and `authz.create_api_key` refuses a key with no name or a blank one (AZ710),
  instead of Postgres's own not-null error.
- `authz.explain` for another user names them as the rest of the API does (`user 5`, asked as `'05'`), and
  `authz.sync_members` records the group's id in the audit trail as its shares hold it (`10`, synced as `'010'`).
- The signature `authz.act_as`, the logins and `authz.view_as` put in `authz.session` signs the settings as a list
  that can be read only one way. Before, they were joined with a separator a user id or a token's subject could
  hold, so two different settings could sign alike.
- `rowstile review` reads a policy with sync lines (`sync role`, `sync app.files : view`, `sync after commit`) and
  shows each one that changed under Meaning, instead of stopping with an error.
- `rowstile review` flags under Risk a sync line added, one that finds its rows' readers by another permission
  (`: view` to `: edit`), or one mirrored now: the sync engine is given rows, and who may read them, it wasn't.
- `rowstile review` reads a backslash in an `E'...'` string as escaping the quote after it, so a change to the text
  after it is a change, not spacing. A condition it can't read (a subquery), respaced outside its quotes, is the
  same condition in its small worlds: a permission turned round and respaced is no longer said to widen.
- `rowstile prove`, `rowstile review` and `rowstile why` read `{user = 'alice'}`, `{current_date is null}` and
  conditions on SQL's other such words as the database does: the role, the session or the clock, not a column of
  the row (`{this.user = 'alice'}` and `{"user" = 'alice'}` still name one).
- `rowstile review`'s listed small worlds keep the rows of a type whose `where` reads a relation's column
  (`where {owner_id is not null}`): they read it from the row's link, where before no such row was ever kept and
  the type was never tried.
- `rowstile review` and `rowstile prove` give each value to the other columns a condition reads beside a
  relation's column (`{owner_id = authz.uid() and not locked}`), in the listed worlds and in the corners, so a
  change behind a long `and` in such a condition shows.
- `rowstile review` and `rowstile prove` try, beside a number a condition compares a column with in order, the
  numbers halfway to one less and one more: a numeric column holds 1.5, where `{level > 1}` and `{level >= 2}`
  differ. A whole number past 8,388,607 so compared is left to the database (a real column rounds the half).
- `rowstile review` and `rowstile prove` give their small worlds a row whose id is one a condition compares a
  relation's column with (`{owner_id <> 7}`: a user 7; `{parent_id = 0}`: a folder 0), and the ids either side of
  one compared in order. Such a condition held on every row or on none there, so the review called a change that
  lets everyone edit user 7's folders unchanged, and prove missed the row that breaks an invariant.
- `rowstile help` says what each code refuses today: AZ607's page tells each migration tool how to record a
  migration the database holds already, AZ203's no longer names `shared by` and scopes (AZ207, AZ404),
  AZ107's names `roles`, and AZ208's message and page name the same uses: a permission, a rule, an invariant,
  a group or a roles line's `from`.
- AZ607's page gives Flyway's and sqlx's own commands for recording a migration as applied, and the row Drizzle
  Kit reads to know one ran. It said those three tools could only make the database again from the migrations.
- `authz.can`, `authz.list`, `authz.perms` and `authz.perms_of` answer for the rows the user may select: on a table
  with a select rule, a row its rule doesn't let them select reads as a missing one (false, left out of the list,
  no permissions). A permission made of conditions on the row, such as the deny the docs teach (`can hidden =
  {hidden} or parent.hidden`), is held by everyone on the rows it marks, and these answers named those rows.
  A table without a select rule answers as before.
  ([GHSA-mfxg-m24m-gfmg](https://github.com/rowstile/rowstile/security/advisories/GHSA-mfxg-m24m-gfmg))
- `rowstile diff` waits for an apply, push or remove running at once, as they wait for each other, instead of the
  two meeting in the middle and one stopping with "deadlock detected". The docs now say that it holds the app's
  tables locked while it runs: run it on a copy or a staging database, not on production at its busiest.
- A migration run a statement at a time (`psql -f` without `-1`), refused (AZ615) with its session made
  read-only, puts the session's setting back in its last statement: a pooler's connection doesn't go on to the next
  client read-only.
- The second of two migrations, which swaps in an inheritance table built beside the one in use, computes the table
  again when the change feed was trimmed meanwhile of the entries of a transaction still open when the first one
  ran. Before, it could miss what that transaction changed. `authz.trim_changes()` records the transaction its trim
  ended at (`changes_trimmed_txid` in `authz.settings`).
- A relation whose two `shared` lines name the same subject with another `shared by` permission or another `shared
  if` condition is refused when compiling, with its line (AZ212). Such a policy failed to apply with `duplicate key
  value violates unique constraint "shared_relations_pkey"` when the permissions differed, and otherwise kept only
  the first line's `shared if`.
- A share with `anyone` is stored with the id `*`, whatever id `authz.share` was given: sharing with `''` and with
  `'*'` makes one share, `authz.unshare` with either id removes it, and `authz.who` counts one made with `''`.
  Applying gives the shares with anyone stored before the id `*`, two of one share kept once.
- Applying after a type's key changed type (text to bigint, say) is refused while shares of rows gone before name
  ids the new key can't read, with the line of the type and how many (AZ627, whose page gives the statement that
  deletes them). It failed with `invalid input syntax for type bigint`, and nothing said which shares or what to
  do. Applying right after deleting them, while a transaction that began before is still open, is refused too, and
  says to apply again once it ends: Postgres builds the index from the rows that transaction still sees.
- A share with `anyone` is stored with the id `*` and no relation, whatever `authz.share` was given: sharing with
  `''` and with `'*'` makes one share, `authz.unshare` with any id removes it (also once the policy no longer
  shares with anyone), and `authz.who` counts one made with `''`. Applying gives the shares with anyone stored
  before the id `*` and no relation, two of one share kept once.
- `rowstile review` reads an included file's name that holds spaces: a mistake's line there (`--json`:
  `base_mistake.line`), and each flag's annotation, on that file and line. `--annotations` escapes the `%`, `:` and
  `,` of a path, as GitHub reads them. Deploy names a quoted table with a space in its name whole, and counts an
  app schema whose name starts with `authz` as the app's. The comment's table escapes a `|` in every cell, an
  invariant's own text too, and a counterexample doubles a quote in a text, as SQL writes it.
- The world `rowstile review` and `rowstile prove` show a difference or a counterexample in leaves out the rows
  that play no part, as it does links and values: one found among 2 users and 4 folders shows the user and the
  folder it is about, not all six.
- `rowstile review` lists 12,000 small worlds at most (60 for each drawn one), even before it has listed every
  world with one link: rows whose conditions give many answers made that many grow fourfold with each condition,
  and a review run for minutes. It then says how far it got ("with no link, and some with one").
- `rowstile review` lists the small worlds where a column compared with `authz.uid()` names a user other than
  the one its row links to (two folders, each made by the other's owner): it took them for the same world with
  the users renamed, which changes whose id the column holds.
- `rowstile init` beside a `rowstile.toml` there already, in its folder or above, that names another policy says
  that no command reads the draft until it does, and the note in `AGENTS.md` names the policy and the tests
  `rowstile.toml` names. Before, it named the draft's.
- An `UPDATE` of `authz.shares` made by hand is recorded with what the share was (`detail`'s `was`: its object,
  relation, subject and times), and announces the object it left also when only its type changed. An `UPDATE` of
  `authz.role_permissions` is recorded (the permission removed, the one added) and announces the objects the role
  is given on. Before, neither was recorded or announced.
- Deleting a row finds the pending access requests and the API keys that name it by index (`authz.requests` has
  indexes of its pending requests, by object and by requester, and `authz.api_keys` one by principal): it no longer
  reads every request ever decided.
- `authz.announce_timed_shares()` keeps each object's next share start or end (`authz.shares_due`, which each
  write of a share puts in) instead of the time of its last run: a clock set back no longer hides the shares that
  end or begin after it until the clock is past that time again. A run waits for a writer adding a share to one of
  the objects it announces, and reads the shares as it left them.
- A `TRUNCATE` run directly on a partition of a watched table, or on a table that inherits from one, is in the audit
  trail, one line naming that table, and the change feed announces every object of its type. A `TRUNCATE` of the
  table above is still one line, naming it. Before, neither heard of the one below.
- A policy with a permission or relation named `tree`, or `tree_` and more (`tree_links`), applies: the closure
  table that an inheritance makes takes another name (`folder__parent__tree2`) where the view of an arrow to that
  name would have had the table's.
- `rowstile migrate` names a file of the migration tool's it can't read and exits 2, where it printed a traceback:
  a Drizzle Kit journal or snapshot that isn't JSON (a merge's conflict markers left in it), a journal entry without
  its `idx` or `tag`, a Django migration that isn't Python, and any of the tool's files, or the lock file, that
  isn't UTF-8. A Drizzle Kit snapshot it can't read leaves no migration file behind.
- The command refuses an option it doesn't take in last place on a line that has `sql` as a value
  (`rowstile migrate --tool sql --check --bogus`): it left the last word out, as it does for `rowstile sql`'s
  statement. A number option given digits of another script (`--worlds ²`) is a usage mistake (exit 2), not a
  traceback.
- `rowstile.toml` refuses a `[migrations] write_after` below 0, which made `rowstile dev` write the migration at
  every save instead of once you stop editing.
- The command run from the source (`core/cli/rowstile`) on a Python older than 3.11 says it needs 3.11 or newer,
  and exits 2, where it stopped with a traceback.
- Ctrl-C stops any command with `stopped` and exit 130: one that reads no database (a long `rowstile prove`,
  `review`, `migrate`), or one still connecting, printed a traceback, as did `rowstile dev` stopped in its first
  pass. `rowstile dev` ends with 0 on Ctrl-C whenever it comes, as it did once watching; `dev --once` with 130.
- The command signs in with a SCRAM password that mixes right-to-left letters (Hebrew, Arabic) with others, or that
  is made only of characters SCRAM drops, as psql does. It prepared such a password other than Postgres had, and
  the server refused it.
- A `#`, a `?` or a `[` in a URL's password is the password's, as libpq reads it. Before, the command refused
  it, or with digits before it connected to the user's name as a host (`postgresql://u:2024#x@h/db`). A message
  about the connection string no longer repeats a piece of a password that wasn't quoted or escaped: a word after
  the password that looked like a setting (`password=my secret=x`), or what came before a `/` in a URL's password.
- A URL's parameter a letter away from a libpq setting (`?sslmod=require`, `?chanel_binding=require`) is refused,
  as a typo, naming the setting meant. Before, it was left alone as an ORM's own, and the command connected
  without what it asked for. An ORM's parameters (`?schema=`, `?pgbouncer=`) are still left alone.
- Studio's grid, on a partitioned table or one that other tables inherit from, marked a row visible when the person
  could see another row stored at the same place in another partition or table. It now tells the tables apart.
- Studio's grid shows a table's columns in the table's order (it put short names first): the first eight, any
  masked column after them, and the names of the others. It counts a table's rows up to 10,000, and says "more
  than 10,000" past that: each page of a big table no longer reads all of it twice.
- Studio's "Make a test" copies json values as the row holds them: a string, a number, a boolean or null in a json
  column made a test that failed. A key that is not a number, text or a uuid is copied as it is, and the test says
  to give the copy a key of its own.
- Studio's access diff no longer says the policy file is the one in force when only an included file changed.
- Studio's page: after the person viewed as changes, the Shares tab's buttons name the new person, and each button
  acts as the person it names. A table's rows that come after rows asked for since are dropped. A graph node the
  policy doesn't name (a permission's inheritance before a deny, a permission's custom roles) shows what it is.
- The lines that show how to use the review for CI (the reference's workflow, the action's and the GitLab
  template's comments) name the newest release, `v0.1.0-beta.3`. On `main` between releases they named its `-dev`
  version, which has no tag to use.
- `rowstile plans` no longer says an index is missing on each partition of a partitioned table it reads (or on each
  table that inherits from it): those scans are the read itself.
- `rowstile bench` times updates of rows the person may update. Before, it picked among the table's first rows
  whoever was signed in, and most of the updates it timed matched no row.
- `rowstile indexes` says that Prisma's and Drizzle's line takes the fields that map the columns, where a model names
  them otherwise, and, for goose and dbmate, that dropping an index a failed build left goes in a migration of its
  own outside a transaction, as the index's line does.
- `rowstile why` and Studio judge a `shared if` as the first 20 of those who may share the object, and say so when
  there are more. Before, they signed in as each of them in turn, for each share they looked at, which took seconds
  on an object a thousand people may share. They also count up to 1,000 objects of a type that someone holds a
  permission on, before and after a change: past that, the permission is said as not counted ("not counted: view
  on folders, past 1000"), not as a number.
- Every SDK reads rowstile's code from the error's HINT alone, never from its message, which may quote the
  request's input: an id of `rowstile help AZ708` cast by the app's SQL is the app's error (a 500), not a 404. The
  PHP SDK reads the HINT libpq writes after the message, and the severity in the server's language.
- Every SDK takes a 28000 as the not-signed-in error only with code AZ701: Postgres's own refusal to connect (a
  role that isn't there, `pg_hba.conf`) stays a database error, instead of naming `authz.act_as`.
- Every SDK but PHP's reads Postgres's own row-level security refusal on a server whose messages aren't English as a
  refusal (403, naming no table), by the function that raised it. The Ruby SDK reads the English words at the
  message's start alone, as the others do, and the TypeScript and PHP SDKs a refusal's rule at its start.
- Nobody has one spelling in every SDK: a principal without an id (none, or empty), whatever its type, is the SDK's
  nobody, as the database signs it in. Work for nobody inside a transaction begun for another spelling of it runs,
  instead of being refused; Django's guard and Ruby's take code that acts for no one, in a transaction signed in as
  nobody, as nobody's work. In Java, `Rowstile.actingAs(null, ...)` acts for nobody, not for whoever the request is.
- Every SDK writes a key as Postgres writes the row, a field quoted for ASCII's six spaces alone: the Python,
  TypeScript, Java and .NET SDKs quoted a field holding a no-break space or an em space, so a hidden row's id and a
  refusal's message spelled it another way than `authz.list`.
- Every SDK takes a key of several columns as any of its language's arrays, lists or tuples: Go any slice or array
  (`[]int64{1, 2}`), .NET any array or list (`long[]`), Java and Kotlin any array or collection (`long[]`,
  `arrayOf(1, 2)`), Elixir a tuple. Before, those were sent as the language's own text (`[1 2]`, `System.Int64[]`),
  and `can` answered false. The Go SDK sends no key as NULL, writes pgtype's values and pointers as their values,
  and refuses a value whose text in Go isn't Postgres's (a `time.Time`, a `[]byte`) before anything is sent.
- The TypeScript and Java SDKs word a hidden row as the others do: `row 7 not found` without the table and `not
  found` with neither, instead of `the row 7 not found` and `null 7 not found`.
- The Elixir and TypeScript SDKs take a null cursor (`after: nil`) as the first page. Elixir sent `""`, which the
  database refused (AZ710).
- The Go SDK: a transaction `Tx` began on a pool no longer forgets the next transaction's sign-in. pgxpool's
  `Commit` puts the connection back in the pool before it returns, and the next transaction on it could begin
  before `Tx` forgot the first: its own nested `Tx`, a savepoint, was then refused as work in a transaction `Tx`
  didn't begin.
- `rowstile.alembic` leaves the sync index's schema alone too (`authz_sync`, made by a policy with `sync` lines),
  so `alembic check` shows no change and autogenerate writes no `drop_table` for its tables.
- The Python SDK's jobs (`rowstile.job`) leave nothing in the context they run in: a worker that ran many jobs in
  one thread held a little memory for each.
- The Python SDK asks the database about the row an ORM update named, when the update was refused: by the key the
  row had (an update may change it), and with joined-table inheritance in the table the change went to. Before, it
  asked about the new key (and answered 404) or the subclass's table (and answered 409, or 500).
- `rowstile.sqlalchemy.install(engine)` keeps no engine alive once the app lets it go.
- The Python SDK's `expect()` reads a table written with quotes (`"app"."notes"`) as the database does, and
  Django's `expect()` and `save()` answer 403 or 404 for a model whose `db_table` names its schema that way
  (`'app"."notes'`), where they failed with AZ707.
- `@rowstile/jest` names `expect`, whose types it adds the matchers to, as a peer: with pnpm's strict layout,
  `toBeRefused` and `toBeNotFound` were untyped.
- `electricShape` (`@rowstile/client`, a preview) finds no filter for a principal type named like a member every
  object has (`constructor`): it answers 403, as for any type the shape doesn't sync.
- `@rowstile/drizzle`'s `ids(type, perm, keyType)` takes a type's name and nothing else: one word, or one of
  Postgres's names of several words (`double precision`, `timestamp(3) with time zone`). Before, it took any words
  with spaces between them, and refused `timestamp(3) with time zone`.
- The TypeScript SDK reads a refusal by a restrictive policy of the app's own, which Postgres names in its message
  (`new row violates row-level security policy "p" for table "t"`), as `Refused`, a 403; before, it was no refusal, a
  500.
- Every other SDK does too (Python, Go, Java and Kotlin, .NET, Ruby, Rust, Elixir, PHP): a refusal by a restrictive
  policy of the app's own, which Postgres names, is `Refused`, a 403, in Postgres's words, with no command but an
  upsert's `update`, and the table it names. Before, it was a refusal that named no table, or in PHP, whose driver
  doesn't say which function raised it, no refusal (a 500).
- Go's `rowstiletest.Refused(t, err, command)` asks for the rule's whole command: before, any start of it passed
  (`"up"`, for an update's refusal).
- PHP: a refusal's DETAIL that quotes a line beginning `LINE 2: ` keeps it; before, the DETAIL went into the message.
  A LINE is libpq's only with the caret it writes under the statement's line.
- PHP: `php artisan rowstile:check` says when the server writes its messages in another language (`lc_messages`), in
  which PHP can't tell Postgres's own row-level security refusal from another error, and still exits 0;
  `Rowstile::check()` returns that warning.
- `@rowstile/prisma` reads a nested write whose target isn't there, or is hidden from the user (a `connect`), as
  `NotFound` naming that target's table. Before, an update named the row it updated, and a create stayed Prisma's
  error.
- `@rowstile/postgres`'s `begin(fn)` runs the queries of an array `fn` returns, as postgres.js's own `begin` does.
  Before, it ran none of them and committed an empty transaction.
- The Java SDK's `Rowstile.transaction` rolls back whatever its work throws. An `Error` (a test's assertion) or a
  checked exception the work doesn't declare (Kotlin's, Lombok's `@SneakyThrows`) left its writes to be committed when
  the connection went back to auto-commit mode. It also takes a connection out of auto-commit mode with no transaction
  open on it (a pool's `autoCommit=false`), and leaves it in its mode, instead of saying a transaction is open.
- The Spring starter ends a transaction whose sign-in fails for any reason, the app's `PrincipalSource` throwing too.
  Before, only the database's refusal did: otherwise the begun transaction stayed bound to the thread, its connection
  out of the pool, and later work on that thread joined it, signed in to no one. A `REQUIRES_NEW` transaction the
  database won't sign in says why (`CannotCreateTransactionException`), instead of Spring's `IllegalStateException`
  about a resource bound already.
- The Spring starter signs in JPA's transactions on any JPA provider (EclipseLink), not on Hibernate alone: without
  it, `JpaTransactionManager`'s transactions were signed in to no one, and their queries failed (AZ701). Saying why an
  entity's update or delete changed nothing is still Hibernate's.
- The Spring starter reads a refused entity delete as a delete with Hibernate's comments in its SQL
  (`hibernate.use_sql_comments`). Before, it asked the update rule why, and could answer 409 where the delete rule
  refused (403).
- The Spring starter makes the transaction manager it hands out with its class's constructor, where it has one without
  arguments (Spring's own managers), and writes no final field by reflection, which JDK 26 warns of and a later JDK is
  to refuse.
- The Kotlin module leaves alone the statements of Exposed's R2DBC transactions, which run its check that a
  transaction is one principal's too: with the module on the classpath, each failed with a `ClassCastException`.
- The Ktor plugin asks who a request is once, when its code first reads it, as its docs say: it asked again on every
  `actingFor()`.
- The Spring starter answers a refused update or delete of an entity whose id has several columns (an `@EmbeddedId`,
  an `@IdClass`) with a 403 that names its table and command, and no reason, instead of a 500: it sent the id's own
  text, which the database couldn't read. Hibernate's order of the id's columns needn't be the policy's key's, so it
  asks nothing ([Spring](/stacks/spring.md)).
- The .NET SDK: in a `TransactionScope` the connection takes part in, SaveChanges and the runtime's calls
  (`CanAsync`, `PermsOfAsync`, `ExpectAsync`) are refused before anything is sent, in the words a command is, which
  say to run them outside the scope or on a connection that takes no part in it (`Enlist=false`); EF Core refused
  them before, in words that didn't say why. A sign-in the database refuses rolls its transaction back
  (`BeginSignedInAsync`, and a context's `BeginTransaction`), so the connection goes on; before, the next statement
  failed. A pooled context (`AddDbContextPool`) rolls back the SDK's transaction after a failed SaveChanges each
  time, not on its first lease alone. `UseRowstile()` takes a named connection string (`Name=ConnectionStrings:Db`),
  which it refused, and leaves it to EF Core. `AddRowstile` says what to give when the start-up check finds no data
  source, and the middleware's problem body replaces what the endpoint had put on the response (its headers, its
  cookies).
- The Ruby SDK's `Rowstile::Job` reads a job's arguments as the job's principal: a record given to `perform_later`
  is found again as the service the job acts for. Before, Active Job read them before the job signed in, so in a
  worker the job failed (AZ701), and in a request it read them as the request's user.
- The Ruby SDK refuses a dump of a rowstile database before `db:test:prepare` (which `maintain_test_schema` runs)
  empties the test database, and before Rails makes a worker's database again from it. Before, the migrated test
  database was emptied first, then the load refused.
- The Ruby SDK keeps Rails from running a statement again on a new connection when the connection drops right after
  the sign-in: the connection's error is raised. Before, Rails began the transaction again without the sign-in, and
  the statement was refused (AZ701).
- The Ruby SDK's `Queries#permitted` works on a model with a composite key. Before, it raised `KeyError`.
- The Ruby SDK holds a statement named `SCHEMA` (as Rails names its reads of the catalog) to the transaction's
  principal, as any other: in a transaction signed in as someone else, it raises before anything is sent.
- The Ruby SDK's `Rowstile.problem_of` works in an app without Rails. Before, it was defined only with the Railtie.
- The Ruby SDK no longer keeps a connection leased after a refused update or destroy, outside Rails' executor (a
  thread of the app's own). `Rowstile.expect` takes `connection: Note` (a model) as well as a connection.
- The PHP SDK reads rowstile's code from the HINT the server wrote, never from text in the message or a DETAIL that
  looks like a HINT line (a value echoed back with a line break in it), and only where the HINT ends with it.
  Before, such a value could give an error another code, and another status.
- The PHP SDK's `SignIn` middleware writes a streamed response (`response()->stream`, `streamDownload`,
  `StreamedJsonResponse`) as the request's principal. Before, the body was written once the request acted for no
  one, and its queries failed (AZ701).
- The PHP SDK's `SignIn` says what is wrong when finding who the request acts for reads a table with rules (the
  users table, read by Laravel's guard before anyone is signed in): a `LogicException` that names it. Before, it was
  the not-signed-in error.
- The PHP SDK answers a `ModelNotFoundException` that names no model (made without `setModel`) as Laravel does, a
  404. Before, it was a 500. One for several ids (`findOrFail([1, 2])`) names none of them, instead of `(1,2)`.
- In a Laravel app, a model's `increment`, `decrement`, `incrementEach`, `decrementEach` and `forceDelete` that
  change no row say why, as its update and delete do: `Rowstile\NotFound` or `Rowstile\Refused`. Before, they
  changed nothing and said nothing.
- The VS Code extension (0.1.5) leaves one language server running when `rowstile.command` changes twice while a
  server starts: another was left running beside it, its mistakes shown twice. A server that didn't start leaves no
  log or problems behind: every server writes to one log, `rowstile`.
- On Windows, the VS Code extension (0.1.5) quotes a word of `rowstile.command` that holds `&`, `|`, `<`, `>`, `^`,
  `(` or `)`, as it did one with a space: `cmd.exe` read them (a folder `R&D`, say).
- Zed, Neovim and Helix read a test whose name holds a quote, as Studio writes some
  (`test "user 1 can view file "a""`), to the last quote on the line, as the parser does. Before, they marked the
  name as an error, and the test went missing from the outline.
- Zed, Neovim and Helix read a condition as Postgres and the parser do where it holds a comment inside a comment, a
  dollar quote with a tag of letters past ASCII, or a character past U+FFFF in a name. Before, they marked it as an
  error, and a brace inside could end the condition early.
- VS Code and the site colour the permission after `shared by` as a permission, and Zed, Neovim and Helix colour the
  scopes of a test line's `with scope`: each editor colours those lines as the others do.
- VS Code and the site end a condition at its last brace when a dollar quote (`$$...$$`, `$tag$...$tag$`) or an
  `E'...'` string inside it holds a brace or a quote. Before, the SQL colouring ended it early, and coloured the rest
  as policy words.
- The Zed extension starts the language server with what Zed's `lsp.rowstile.binary.env` setting sets, and adds no
  closing quote to one typed inside a test's name, a quoted id or a comment. Before, it ignored that setting, and
  closed every quote.
- The playground's app role may use the schema `public`, as on a server: tables there (Prisma's, Django's, Rails')
  are read and written under the policy. Before, each run made `public` again without its usual owner and grants,
  so asking as someone was refused there. Each run also starts from a new session: what the last run's tables and
  data set (`SET search_path`, `SET session_replication_role`, a temporary table) is gone.
- A playground link that names no example (`#e=` and a recipe renamed or removed since) opens the first one and
  says that no example has that name. Before, it opened the first one and said nothing.
- The file manager example: a new version of a file whose own upload wasn't confirmed yet is refused (404). It
  became the file's current one while the file stayed hidden, and the maintenance job then stopped on the
  version's foreign key, leaving the file hidden for good with its name taken. The job removes a file never
  confirmed with every version it has.
- The file manager example's policy: only a group's owner hands it over or deletes it. Its admins still run its
  members and sub-groups, but they could make themselves its owner, which took the group from the person who made
  it, and delete it. The web app offers Delete only to the owner.
- The file manager example reads `FM_COOKIE_SECURE` and `FM_OPEN_SIGNUP` as true or false (or 1 and 0) in any
  case, and stops at start on another word: `TRUE` left the session cookie on plain HTTP. `FM_WEB_ORIGINS` may
  have spaces after its commas.
- The file manager's web app searches for a link's words as written when they hold a `%` that is no escape
  (`#/search/50%`): the page went blank.
- The file manager's maintenance jobs remove the objects in storage that no file's version names, after a day: a
  deleted file's objects, when deleting them failed after its rows were gone, stayed in the bucket for good.
- A type keyed by a date, a time, an interval or money is refused when the policy compiles, naming its line
  (AZ206). Before, applying failed with Postgres's own message about an index, which named no line.
- `rowstile review --db`: Risk's example of a permission that allows more is someone Access shows gaining it on
  the review data, when it shows one. Before, it came from the review's small worlds alone, and could name a user
  who held the permission already.
- `rowstile why` and Studio say "more" and "other" only of objects of the type asked about: a change that also
  gives edit on a note's one project says "edit on 1 project", not "on 1 more project".
- In a condition, a `$` right after a character beyond ASCII (an em dash, an emoji) goes on the name, as Postgres
  reads it, and opens no dollar quote. Before, the policy read the rest of the line as quoted.
- The file manager's migrations run in a service of their own in `docker-compose.yml`, which ends before the app
  starts, and its maintenance jobs in another (`docker compose run --rm maintenance`): the app no longer holds the
  database's admin password, only `fm_app`'s.
- The file manager's migrations, maintenance jobs and tests run as `fm_owner`, the tables' owner, which isn't a
  superuser (`db/owner.sql`, run once by the Postgres image when it makes the database), as the messenger's do;
  they ran as the superuser. Its database is published on 127.0.0.1 only. A database compose made before has no
  `fm_owner`: start it afresh (`docker compose down -v`).
- The messenger example's rules: a direct chat stays its two people, whoever left. Its creator who had left it, or
  the one who stayed, could put someone else in it, and its creator could start one between two others. A
  message deleted for everyone loses its text, whoever writes it (only the API cleared it). A member marks read
  no further than the chat's last message, and someone added has read what came before, which they never see:
  read receipts showed messages not sent yet as read, and old ones as unread once someone joined. A phone number
  shows only to the people who share a chat with its person (the app reads people through a masked view); anyone
  else finds an account by its exact number (`ms.find_by_phone`). Every signed-in person and bot could read
  everyone's. Signing up reads the phone number before checking it: `abc` was kept as an empty number, which any
  phone made of letters then found. A path under `/api/` the API doesn't have answers 404, not the web app's page.
  Opening a direct chat whose other person left blanked the web app, again on each reload; it opens, unnamed. Its
  schema is one migration, as the file manager's is.
- The messenger example's rules and API: a direct chat stays its two people, whoever left. Its creator who had
  left it, or the one who stayed, could put someone else in it, and its creator could start one between two
  others. A message deleted for everyone loses its text, whoever writes it (only the API cleared it). A member
  marks read no further than the chat's last message, and someone added has read what came before, which they
  never see: read receipts showed messages not sent yet as read, and old ones as unread once someone joined. A
  phone number shows only to the people who share a chat with its person (the app reads people through a masked
  view); anyone else finds an account by its exact number (`ms.find_by_phone`). Every signed-in person and bot
  could read everyone's. Signing up reads the phone number before checking it: `abc` was kept as an empty number,
  which any phone made of letters then found. A path under `/api/` the API doesn't have answers 404, not the web
  app's page. Opening a direct chat whose other person left blanked the web app, again on each reload; it opens,
  unnamed. Its migrations run in a service of their own in `docker-compose.yml`, so the app no longer holds the
  tables' owner's password, and its schema is one migration, as the file manager's is.
- The clients `rowstile client py` and `rowstile client ts` write a key of several columns in a message as
  Postgres writes the row: a field is quoted for ASCII's six spaces, not for a no-break space or another Unicode
  space, and a NULL field is nothing (it was `None` or `null`). A key of one value given as a tuple or an array is
  that value, in a message and in what they send: `(7,)` was sent as `("7")`.
- The review for CI on GitHub: when GitHub can't be reached, or doesn't answer within 30 seconds, the comment step
  fails with an error that says so and that the review is in the run's summary. Before, it ended with a traceback,
  or waited for the job's timeout.
- A mistake on a line that goes on over several (a quote left open in braces, AZ106 and AZ114), or about a quote left
  open to the end of its line (in a condition or a test's statement), is underlined in the editor and the review up
  to the last character of its words. Before, the range ended one character past the end of that line.
- The npm package's launcher passes Ctrl-C and a hang-up on to the command only when none of its streams is a
  terminal: `npx rowstile ... < file` in a terminal no longer gives the command each one twice.
- The command's image and the Python package are built with the build's own packages (hatchling and what it needs)
  pinned by hash, as everything else they fetch is.
- `rowstile review` and `rowstile prove` read a condition on a type's key column (`{id = 2}`) as the row's own
  id, as the database does. Before, their small worlds gave that column a value of its own, beside the id, so a
  refactor could be said to change what it doesn't, or a counterexample be one no database can hold.
- `rowstile migrate` writes a migration when a policy's lines only moved (a comment added above a rule): it writes
  where each line is now, and nothing else, and `rowstile migrate --check` asks for it. Before, there was none, and
  a migrated database's messages named a rule's old line until the next migration.
- The language server, when a file a policy includes is closed while the policy is open, marks it with what the
  policy's check finds there. Before, with no policy named in rowstile.toml, it kept the mistakes the file had
  when read as a policy alone (no app role, say).

### Upgrading

- An Axum app's `impl SignIn` writes `async fn principal(&self, request: &mut Parts) -> Result<Principal, Error>`
  where it wrote `fn principal(&self, request: &Parts) -> Result<Principal, Error>`; the body stays as it was.
- A condition with a string, a quoted name or a dollar quote over several lines is refused (AZ114): write it on
  one line, a line break in a string as `E'\n'`.
- A type, a relation or a permission whose name starts or ends with `_` is refused (AZ107), with the line it is
  on: rename it.
- Code that signs one transaction in as two principals now gets AZ716: begin a transaction for each. A test that
  acts for several people in one transaction calls `authz.sign_out()` between them, as the SDKs' test modes do.
  The next apply (or migration) makes the change.
- Sign-ins are signed in a new way. A signature lasts one transaction, so a connection pool keeps none across the
  upgrade. `rowstile apply` and `push` wait for the transactions signed in before them; a migration doesn't, and a
  transaction signed in before it and still open when it commits gets AZ702 on its next statement: retry it.
- A reader of the change feed reads everything again once after the upgrade, then follows from
  `authz.changes_position()` (no longer `max(pos)`, which may stand past an entry still to come).
- A review started more than two weeks ago with the default deadline takes no more decisions: close it, or start
  it again.
- The next apply (or migration) makes `authz.shares_due` from the times the shares have after the last
  `authz.announce_timed_shares()`, and drops the indexes `authz.shares_by_end` and `authz.shares_by_start`, which
  nothing reads any more.
- A Go app whose `user` function, given to `rowstile.Middleware`, refuses a bad token with an error of its own
  returns `rowstile.Unauthorized("...")` instead: any other error is now a 500.

## 0.1.0-beta.3 (2026-11-05)

The sync index, its engines (Electric, Zero, PowerSync) and the new SDKs and stacks are previews: they may
change in any release, and the SDKs not on a registry yet install from the repository.

### Added

- `rowstile dev`'s access lines name, under a permission someone gains, the rules that read it (`read by the
  rules of app.folders: update id, owner_id, org_id, inherit; delete`): whoever gains `share` may then also do what
  those rules let `share` do, such as give a folder away.
- The sync index, a preview (its lines, tables and functions may change in any release): `sync role sync_engine`
  names the sync engine's Postgres role, and `sync app.files : view` (or `sync app.folders`, for the table's select
  rule) keeps, in the schema `authz_sync`, the keys that may read each row and the keys each user holds, current in
  the same transaction as each change, for engines such as Electric to replicate. `authz.sync_tick()` follows shares
  that start or end, and `authz.sync_verify()` compares the index with a rebuild. AZ801 to AZ809 are its mistakes
  ([The sync index](/reference/sync.md)).
- The sync index, a preview, keyed by folder: `sync app.files : view by folder` names in each file's readers its
  folder's key (`folder#view:7`), and the index says whose own keys it inherits (`authz_sync.inherits`) and what
  each folder gives itself (`authz_sync.given`), which the engines' filter joins through: a move rewrites no file's
  readers and no key, only what the folders below inherit, and a share on a folder is one row, whatever is below it;
  each user holds their own and their groups' keys, as copied in (AZ810 where a line can't be keyed so). `sync after commit` has a worker,
  `authz.sync_work()`, keep the index after each change commits, so writers don't wait for it;
  `authz.sync_behind()` says how late it is. In the same transaction, writers whose work on the index meets
  nowhere don't wait for each other ([The sync index](/reference/sync.md#keyed-by-folder)).
- Electric on the sync index, a preview: `rowstile client electric` (or `[clients] electric`) writes each synced
  table's shape (its filter for the signed-in principal, its key columns, the columns the policy masks), and
  `electricShape()` in `@rowstile/client` is the route in front of Electric that sets it, whatever the client sends:
  401 for nobody, 403 for a session limited by scopes, `Vary` on who asks. Its conformance suite runs Electric
  (`integrations/electric`, [The sync index](/reference/sync.md#electric)).
- A stack page for Electric, a preview: the role an administrator makes, the publication the app's migration
  makes, `rowstile client electric`, the route with `electricShape` and `syncPrincipal`, `Vary` and a cache, and
  what can't be done ([Electric](/stacks/electric.md)).
- `authz.session_limited()` says whether the signed-in session is limited, by a key's or a token's scopes or by
  viewing as someone, believing the settings only when they are signed, as the rest of rowstile does. The app role
  may call it; `syncPrincipal()` in `@rowstile/client` asks it. A migration
  brings it ([Identity](/reference/identity.md)).
- Zero on the sync index, a preview: `rowstile client zero` (or `[clients] zero`) writes the index's tables as Zero
  tables, with their relationships, each synced table's relationship to its readers, the columns the policy masks,
  and each table's filter, which the app's query endpoint adds to the ZQL it gives zero-cache. Its conformance suite
  runs zero-cache 1.11.0 in each of the index's modes, with Zero's query and mutate endpoints signing each request
  in (`integrations/zero`, [The sync index](/reference/sync.md#zero), [Zero](/stacks/zero.md)).
- PowerSync on the sync index, a preview: `mirrored` on a sync line (`sync app.files : view mirrored`) keeps a copy of
  the table in `authz_sync`, every column but those the policy masks and `readers`, the keys that may read each row,
  kept as the rows and their readers are written; and `rowstile client powersync` (or `[clients] powersync`) writes
  the service's streams, which put each row in a bucket for each key that may read it, its columns read from the
  database. AZ811 refuses a mirrored line keyed by a type, and a table with a column of its own named `readers`. Its
  conformance suite runs the PowerSync service 1.27.0 in both modes a mirror takes (`integrations/powersync`,
  [The sync index](/reference/sync.md#powersync), [PowerSync](/stacks/powersync.md)).
- `authz.announce_timed_shares()` tells the change feed of the shares that ended (`expires_at`) or began
  (`starts_at`) since it last ran, and of what reads their objects. Run it on a schedule, as `authz.trim_changes()`
  is run ([Operations](/operations.md)): no write marks the moment a share ends, so until it runs a reader of
  the feed doesn't hear of it.
- Background jobs in Celery's and RQ's workers, for the Python SDK (preview): `rowstile.job(who)` is a `with` block
  too, for a job that acts for the user its argument names (`Principal.parse`). In either form, the database's
  refusals inside it are raised as `Refused` and `NotFound` (the decorator let the driver's error through before).
  The two keep what they say in their arguments, so pickle and Celery's results give them back whole. The FastAPI
  conformance suite runs them in both workers, on Redis.
- Django, as a preview (it may change in any release): `rowstile[django]` signs every transaction on Django's
  connections in as the request's user (`"rowstile.django"` in `INSTALLED_APPS`, and its middleware), answers
  refusals with 403 and hidden rows with 404, and gives pytest-django a copy of the test database per worker.
  `rowstile migrate` writes Django migrations (`tool = "django"`). [Django](/stacks/django.md).
- Preview: the TypeScript SDK on Neon's serverless driver (`@neondatabase/serverless`): `@rowstile/pg` takes its
  `Pool`, over WebSockets, on Node.js and on Next.js's edge runtime, where `checkAtStart` now throws, saying why,
  instead of reaching for `process.exit`. A BullMQ worker and Next's `after()` sign in as `job()` or the request
  say. The Next.js suite checks each, through Neon's `wsproxy` and a real Redis.
- `@rowstile/jest`, a preview: `@rowstile/vitest`'s matchers, `asUser` and a test database per worker, for Jest 30.
  And a conformance suite for a plain Node server, also a preview: Express 5 on pg, Drizzle and postgres.js, with
  Drizzle Kit's migrations and its tests on Jest (`integrations/node`, the Node page).
- A Go SDK, as a preview (`github.com/rowstile/rowstile/sdk/go`, on pgx): transactions signed in, refusals as
  `Refused` and `NotFound`, `net/http` answers, a test database per package; `rowstile client go` writes the
  policy's names for it. Its conformance suite runs a `net/http` app with sqlc's queries and goose's migrations.
- A .NET SDK, as a preview (it may change in any release): `Rowstile`, `Rowstile.EntityFrameworkCore` and
  `Rowstile.AspNetCore` sign each transaction in as the request's user and answer refusals as the other SDKs do,
  `rowstile migrate` writes EF Core migrations (`tool = "efcore"`), and `rowstile client csharp` the policy's names.
- The Ruby SDK for Rails apps, a preview: the `rowstile` gem signs every Active Record transaction in, answers
  refusals 403 and hidden rows 404, refuses to start on a connection that skips row-level security, signs Active
  Job in as a service and copies the test database for each worker. `rowstile migrate` writes Rails migrations
  (`tool = "rails"`), and `rowstile client ruby` and `rbs` the policy's names and their signatures, for Steep.
- A Java SDK, in preview: `dev.rowstile:rowstile` over JDBC, and a Spring Boot starter that signs in every
  transaction Spring begins as the request's user and answers refusals with problem details
  (`docs/stacks/spring.md`). `rowstile client java` writes the policy's names for it. It may change in any release.
- A Kotlin module for the Java SDK, in preview: `dev.rowstile:rowstile-kotlin` signs in transactions from coroutines
  and Exposed's, and its Ktor plugin signs in each request's and answers refusals with problem details
  (`docs/stacks/ktor.md`). It may change in any release.
- A Rust SDK, in preview: the `rowstile` crate signs sqlx and tokio-postgres transactions in, turns refusals into
  typed errors and problem details, and gives Axum an extractor for each request's transaction
  (`docs/stacks/axum.md`). `rowstile migrate` writes sqlx migrations (`tool = "sqlx"`), and `rowstile client rust`
  the policy's names. It may change in any release.
- An Elixir SDK, a preview: the `rowstile` package signs Ecto and Postgrex transactions in, answers refusals
  403 and hidden rows 404 (a Plug, and a Phoenix fallback), refuses to start on a connection that skips row-level
  security, signs Oban jobs in for the user who asked, and copies the test database for each test partition
  (`docs/stacks/phoenix.md`). `rowstile migrate` writes Ecto migrations (`tool = "ecto"`), and `rowstile client
  elixir` the policy's names. It may change in any release.
- A PHP SDK, a preview (it may change in any release): `rowstile/rowstile` signs PDO transactions in, and in Laravel
  every transaction as the request's or the job's principal, answers refusals 403 and hidden rows 404, and copies
  the test database for each worker. `rowstile migrate` writes Laravel migrations (`tool = "laravel"`), and
  `rowstile client php` the policy's names as enums ([Laravel](/stacks/laravel.md)).

### Changed

- `rowstile init` takes the policy's app role from the database: the one role the tables are granted to, where it
  wrote `app_user` whatever the app's role was. It says so, and asks to make no role that is there (one that skips
  row-level security: what to change). With several roles granted the tables it names them, and with no tables it
  says the app's migrations come first.
- A refused share or unshare (AZ705) says why, as a refused write does: its DETAIL is what `authz.explain` answers
  the one sharing, for the permission sharing takes (for an object they can't see, what one that isn't there gets).
  The SDKs give it as `why`, which was empty.
- AZ607's title names its most common case: "The database holds the migration already, or isn't where it starts".
- The site's Markdown copy of each page (`/reference/language.md`) and `llms-full.txt` leave out the notes that
  say which check holds each sentence (``), which the pages don't show either.
- A transaction is one principal's, in every SDK. Inside a transaction an SDK signed in already, work for someone
  else, or for no one, is refused before anything is sent for it, with the same words everywhere ("this
  transaction is signed in as user 1 already, and a sign-in lasts the database transaction: service 1's work can't
  run inside it. Run it after, or in a transaction of its own (another connection)", each principal named by its
  type and id, or `nobody`); the transaction goes on as its own principal's. Work for the same principal goes on as
  before. Until now the SDKs differed:
  - Python: `rowstile.psycopg` and `rowstile.asyncpg` blocks took a savepoint and signed back after;
    SQLAlchemy's `install(engine)` kept the outer principal; `rowstile.django` switched statement by statement.
    Each now raises a `RuntimeError`. A psycopg or asyncpg block inside a transaction it didn't begin is refused
    too (who it is signed in as can't be known): psycopg without autocommit opens one at the first statement.
  - TypeScript (`@rowstile/pg`, `/postgres`, `/drizzle`, `/prisma`): opened a second connection (on a pool of one,
    it waited until the pool's timeout). It now throws an `Error`; `@rowstile/client` exports `signedInAlready`.
  - Go: `Tx`/`TxAs` for someone else took a savepoint signed in as them; now an error. So is `Tx` on a transaction
    it didn't begin, or on a `*pgx.Conn` or a `*pgxpool.Conn` in a transaction. To begin one with pgx's options (an
    isolation level, read only), `rowstile.Tx(ctx, rowstile.WithOptions(pool, opts), fn)`.
  - Ruby: switched statement by statement; now a `RuntimeError`. In Rails' transactional tests, each transaction
    the app begins is one principal's, so a test may still act for one person, then another.
  - Django's tests the same: inside the test's transaction, each atomic block the app begins is one principal's.
  - EF Core (`UseRowstile()`) and the Spring Boot starter kept the transaction's principal without a word; now an
    `InvalidOperationException` and an `IllegalStateException`. In Spring, both work that joins the transaction and
    each statement on its connection are checked (a `JdbcClient` call, JPA's, an `Authz` call). The transaction
    managers are handed out as a subclass of their class, so the app may inject them by class
    (`JpaTransactionManager`) or as a `PlatformTransactionManager`; the app's `DataSource` beans the same.
    `Rowstile.signedInAlready(signed, who)` in the Java SDK is the error.
  - Kotlin: `transaction` and `suspendTransaction` refused another principal's inside one of theirs already; now
    each statement in one is checked too (Exposed's, `calls`, and those on `DataSource.transaction`'s connection),
    and inside a blocking `transaction`, `actingFor()` is the principal it signed in as.
  - Rust, Elixir and PHP refuse as they did (Rust's types already keep a transaction to one principal; the other
    two refused already). .NET, Java, Kotlin and Elixir named a principal `1` or `service:1` in the words, and now
    `user 1` and `service 1`; .NET, Java, Python, Ruby and PHP said "the work of code that acts for no one" where
    the others say "nobody's work", which every SDK now says.
- The .NET SDK turns on Npgsql's `Include Error Detail` where it builds the app's connections:
  `AddRowstile(o => o.ConnectionString = ...)`, which now builds the `NpgsqlDataSource`, and a context's
  connection string before `UseRowstile()`. A refused write says why without the app setting it. A data source the
  app builds itself keeps what it was built with.

### Fixed

- `rowstile prove` and the review's refactor check: a relation on the type's own key (`self : user = id`) holds
  on every row's own, in every world they try. They could report a counterexample where it didn't, which no
  database can hold.
- `authz.break_glass` checks the relation's `shared if` for whoever breaks the glass, as `authz.share` does for
  any share, and refuses with the policy's line when it doesn't hold.
  ([GHSA-x952-p96h-53wg](https://github.com/rowstile/rowstile/security/advisories/GHSA-x952-p96h-53wg))
- The pages of the SDKs that aren't on a registry yet install them from the repository: the Rails, ASP.NET Core,
  Laravel and Phoenix pages, and the .NET, Rust and Elixir SDKs' own, named packages RubyGems, NuGet, Packagist,
  Hex and crates.io don't have. The README and `llms.txt` list every stack page, and the guide every migration tool.
- The Next.js page: `init` comes after the migrations that make the tables and the app role, not in the install
  lines; the owner's URL is `DATABASE_URL`, the variable `init` writes in `rowstile.toml` and Prisma reads (the
  page used another, so following it gave two); and `prisma migrate resolve --applied` is for the migrations after
  the first, which applies over what `rowstile dev` pushed. The sharing recipe says that the rules reading `share`
  open with it. Paths the docs name as proof are links, and `llms.txt` links the playground on the site.
- The TypeScript SDKs (`@rowstile/pg`, `@rowstile/postgres`, `@rowstile/drizzle`): work that `transaction(fn)`
  (`begin(fn)`) started and that ran after it ended (a promise `fn` didn't await, a timer) still ran on the
  transaction's connection, which by then could be serving another request's transaction, signed in as someone
  else. That work now runs in a transaction of its own, as whoever it acts for.
  ([GHSA-rjcp-7gwg-4mqw](https://github.com/rowstile/rowstile/security/advisories/GHSA-rjcp-7gwg-4mqw))
- `rowstile init` no longer tells a Prisma 7 app to sign in inside Prisma's generated client
  (`src/generated/prisma/client.ts`), which the next `prisma generate` replaces: it skips generated files.
- The Next.js page: its `prisma.config.ts` loads `.env` (`import "dotenv/config"`; Prisma 7 doesn't), and its
  page reads inside `<Suspense>`, which `next build` needs with Cache Components, on in a new `create-next-app`.
  The conformance app now runs with Cache Components.
- The change feed announces what reads a changed object through a relation, and what reads those in turn, with
  the cause `dependent`. It announced only the object itself, so a reader missed objects whose access had
  changed: the files in a moved folder (whose view reads the folder's); the folders and files a team is given,
  shared with or given a custom role on, when a member joins or leaves it (and the teams it sits in); the folders
  of an org whose admins change. Past a thousand objects of a type it says `{*}` for that type. A custom role
  whose permissions change announces the objects it is given on (the cause `role`), and every type's table tells
  the feed of its rows, where before only tables whose columns hold relations did: a change to a column a
  condition reads, or a row of a type only link tables name added or deleted, went unannounced. An update is
  announced only where it changes a row's key, a relation's column or a column the type's conditions name (any
  column, where the compiler can't tell which they read); before, every update of a row whose columns hold
  relations was, a file's renaming too.
  Writes that reach other objects take a little longer: on the docs app, a member leaving a team or a share on a
  folder about half a millisecond more; at most a thousand objects of a type are looked up ([Limits](/reference/limits.md)).
  ([GHSA-7f4r-8j8w-g94j](https://github.com/rowstile/rowstile/security/advisories/GHSA-7f4r-8j8w-g94j))

### Upgrading

- Work for another principal, or for no one, inside a transaction an SDK signed in already now raises (see
  Changed): run it after that transaction, or in a transaction of its own on another connection.
- An app that reads the change feed, with shares that end or begin at a time (`expires_at`, `starts_at`): schedule
  `authz.announce_timed_shares()`, as `authz.trim_changes()` is, or the feed doesn't hear of those shares
  ([Operations](/operations.md)).

## 0.1.0-beta.2 (2026-10-29)

### Changed

- The Python the npm packages bring is CPython 3.13.18 (python-build-standalone 20261026), where it was 3.13.17.
- `authz.cancel_request` writes a line in the audit trail (`cancel_request`, the request's object, relation and
  requester, and the request's id), as deciding a request does. Before, a withdrawn request left no trace there.
- An empty condition is refused (AZ102, "empty {} condition") in a type's or a link table's `where`, a `shared if`
  and a caveat, as it already was in a permission or a rule. An empty `where` or `if` was read as none, so the type
  or the relation took more rows than meant; an empty caveat compiled to SQL that Postgres refused on apply. A
  policy that has one: write the condition, or take the `where {}` (or `if {}`) away.

### Fixed

- A condition that calls a function or an operator of the app's (`{not app.blocked(this.id)}`) runs with the
  policy's rights where a view reads its permission too: another type's rule through an arrow (`file.open =
  doc.open`), a permission that inherits, a masked view. There it ran with the app role's rights, so a function
  reading a governed table saw only what the signed-in user may see: under a `not`, row-level security could
  show rows the policy refuses (`authz.can` and a type's own select rule were right); otherwise it hid rows the
  policy grants, and a function reading the permission's own table made every read fail ("stack depth limit
  exceeded"). Conditions written as subqueries were not affected.
  ([GHSA-gfc6-697v-pv35](https://github.com/rowstile/rowstile/security/advisories/GHSA-gfc6-697v-pv35))
- The npm packages that hold the command's Python name its licence `Python-2.0` in their `license`, where they
  said `PSF-2.0`: the licence file they carry is CPython's whole licence (the PSF, BeOpen, CNRI and CWI
  agreements), which SPDX names `Python-2.0`; `PSF-2.0` is only the first of them.
- `rowstile review` flags a `shared if` taken off or rewritten for one subject of a relation shared with several
  (`viewer : user shared if {...}` beside `viewer : team#member shared`). It compared the relation's conditions
  together, and a subject shared without one hid the change of another's. The flag names the subject there:
  "`doc.viewer` for `user`: its share condition changed".
- The review's GitHub action and GitLab template update only the comment their token wrote. They took the first
  one that starts with the review's marker, whoever wrote it: a person's comment starting so was overwritten with
  the review, or GitHub refused the edit and the job failed. Now theirs stays, and the review is posted beside it.
- The VS Code extension (0.1.4) stops the language server it was starting when `rowstile.command` changes, once
  that server has started. It was left running beside the new one, and each mistake was shown twice until the
  window was reloaded.
- `authz.view_as` in a session limited by scopes (an API key's, a JWT's) keeps those scopes. It gave the session
  the scope `read`, so a key whose scopes let it view as a user read everything that user may, beyond what the
  key itself was given. A session without scopes still views with `read`. The session's signature and a JWT's
  are now compared through their hashes, so the time a comparison takes says nothing of how much of one is right.
  ([GHSA-xjmp-62rc-xfcq](https://github.com/rowstile/rowstile/security/advisories/GHSA-xjmp-62rc-xfcq))
- `authz.explain` says to whom a custom role was given when it was given to `anyone`, to every signed-in user
  (`user:*`) or to a link: "a custom role given to anyone (by 1) (role reader)". It said "a custom role given to
  (by 1)", naming nobody.

## 0.1.0-beta.1 (2026-10-22)

### Added

- `cascade from schema.table` under a table's rules says that its foreign key to that table deletes or changes its
  rows as meant (`ON DELETE CASCADE`, `SET NULL`, ...), and applying no longer warns of it. Where several keys
  to that table act, the line names the key's columns: `cascade from app.users (owner_id)`. Applying refuses a
  line that names no such key, or several (AZ625); a column it names that the table doesn't have is said as such
  (AZ601). The review flags a line added, `rowstile fmt` lays it out, and the editors highlight it.
- Versions have a beta stage, `X.Y.Z-beta.N` (on PyPI `X.Y.ZbN`), after the version's alphas and before its
  release candidates. The command orders versions so when it refuses to apply, push or migrate over what a
  newer version wrote (AZ616), and `rowstile init` asks a Python app for at least the beta it runs
  (`rowstile>=0.1.0b1`).
- Codes for the mistakes `rowstile init` and `rowstile snapshot` report, each with its page (`rowstile help
  AZ621`): AZ620 (no tables to draft from), AZ621 (which table holds the users), AZ622 (a users table the draft
  can't use), AZ623 (too many people for a snapshot).
- `rowstile review --out FILE` writes the pull request comment to FILE as well, beside what it prints:
  `--annotations --out review.md` gives both from one review. The GitHub action runs the review once this way,
  where it ran it twice (the base's tests and the access comparison too).
- The command's image (`ghcr.io/rowstile/rowstile`) is built for arm64 as well as x64: on an Apple Silicon Mac
  or an arm64 machine, Docker runs it without emulation. Its label `org.opencontainers.image.version` says its
  version, and it comes with its provenance, signed through Sigstore by the release workflow that built it:
  `gh attestation verify oci://ghcr.io/rowstile/rowstile:<version> --repo rowstile/rowstile` checks it.
- The Next.js page has a part on Next.js with pg, without Prisma. The reference names the columns
  `authz.list_shares` returns.

### Changed

- The beta starts afresh: it doesn't upgrade a database an alpha made, and no longer reads the names from before
  the rename (`rowfence.toml`, `ROWFENCE_PYTHON`, the marks rowfence wrote). Apply the policy to a new database,
  or to the same one after `rowstile remove --yes` (shares and history stay).
- The example apps (the file manager, the messenger) and the conformance apps (FastAPI, Next.js) each have one
  migration for their policy, written by this version's command: they kept every migration since the first
  alpha, about 45 each. The file manager's tables are one migration too, and the conformance apps no longer set
  `jit = off` on their app role (the sign-in turns JIT off for its own transaction). A database one of them made
  before is made anew: `docker compose down -v`.
- The Python package's extras ask for the versions its conformance suite runs on: FastAPI 0.110, asyncpg 0.29
  and psycopg 3.1.4 or newer (they allowed FastAPI 0.100, asyncpg 0.28 and psycopg 3.1, which nothing ran). The
  suite also runs each night on the oldest versions the extras allow.
- `rowstile review` says "Meaning unchanged: no declaration changed" when no declaration of the policy changed.
  It said "unchanged (only comments, spacing or order)", also on a pull request that didn't touch the policy.
- The VS Code extension (0.1.3) is no longer marked a preview on the Marketplace and Open VSX, and asks for VS
  Code 1.82 or newer, the oldest its language client runs on (it said 1.75).
- The npm packages ask for Node 22.12 or newer: the `rowstile` command said Node 18, and the TypeScript SDK's
  packages said nothing. The SDK's peer ranges name the majors its checks run, no longer any later one:
  `@rowstile/next` Next.js 16 (it said 15 or later), `@rowstile/react` React 19 (18 or later), `@rowstile/prisma`
  Prisma 7 (7 or later), `@rowstile/postgres` postgres.js 3 (3.4 or later), each from the version the checks ran.
- The npm packages with the command's Python are about 10 MB smaller each (`@rowstile/cli-linux-x64`: 15 MB to
  download, from 26). They no longer carry `libpython` (on Linux and macOS the Python is linked statically and
  never loaded it), `python3.13-config`, or the `dbm` module's C part (Berkeley DB on Linux), which the command
  never uses. Their `license` names the licence of each library in that Python, beside Apache-2.0 and PSF-2.0,
  and they carry those texts only.
- `rowstile init` drafts a team inside a team as nested membership: the members of the teams inside count as
  members of the team above (`member : team#member = app.teams(parent_id -> id)`), where the draft passed the
  team above's view down. A comment says the other reading. For teams, groups, orgs, departments and the like;
  folders still pass their view down.
- `rowstile init` adds to `package.json` only what the app needs to run, and says why each: `@rowstile/react`
  and `@rowstile/vitest` are named, not added.
- `rowstile init --db URL` in an app whose `DATABASE_URL` (in the environment, `.env` or `.env.local`) is another
  connection, often the app's, as its role, writes `database = "env:ROWSTILE_DATABASE_URL"` in `rowstile.toml`,
  and says to set it to the owner's. It wrote `env:DATABASE_URL`, and the next command connected with the app's
  URL. With `--db`, the line `found ..., Postgres` no longer says the connection came from `DATABASE_URL`.
- The command refuses an option the command doesn't take, naming it, exit 2: another command's (`check --force`,
  `apply --check`, `migrate --development`), `--db` on `check`, `prove`, `fmt` and `migrate`, which read no
  database, and one written with a single dash (`check -x p.authz` blamed the policy file). Each was ignored
  without a word. `rowstile graph` and `rowstile client` with `--db` read the policy in force on that database,
  not the file `rowstile.toml` names, and refuse `--db` beside a policy file.
- `rowstile --help`, `-h` and `help` print the usage on stdout, for a pager or `grep`; `--help` after a command
  that doesn't exist says so, exit 2. A command short of an argument says how many it takes, and shows its
  usage.
- TypeScript: `Problem`, what `problemOf(e)` returns, types its fields (`table`, `command`, `why`, `code`
  besides `status`, `type`, `title`, `detail`), so a field it hasn't, such as `p.body`, is a type error.
- The generated Python client's `share` takes `caveat_args` as a dict, `{"ip": "10.0.0.7"}`, as the TypeScript
  client's `caveatArgs` and `explain_rule`'s row do (it took JSON text). Regenerate the client.
- `rowstile.sqlalchemy.why_stale(exc)` and `why_stale_sync(exc)` take the `StaleDataError`, which they no longer
  may leave out: the SDK asks the database why a flush failed before its transaction is rolled back, and puts the
  answer on the error.
- `rowstile.sqlalchemy.install(engine, user=...)` given a `user()` for an engine installed without one (as
  `Rowstile(app, engine)` installs it) takes it, where it was ignored. Another `user()` than the one the engine
  has is a `ValueError`, where the first one stayed without a word.
- In `rowstile.testing`, a test that never awaits what `assert_refused` or `assert_not_found` returned for an
  async function fails at teardown and says to await it. It passed without checking anything.
- The operations page (Behind a pooler) says what runs every night: both SDKs' conformance suites with the app's
  connection through PgBouncer in transaction mode, keeping prepared statements. It asks for the command and
  migrations on the direct URL or a pooler in session mode, as the change feed (it said they ran through a pooler
  too), and says when Supavisor, PgCat, Neon and Supabase were tried by hand.
- The speed figures on the limits page and the benchmark's page say what measured them: a build of 2026-10-03,
  on the laptop the project was developed on then. No build since has run those sizes.
- The Python the npm packages bring is CPython 3.13.17 (python-build-standalone 20261021, with OpenSSL 3.5.9),
  where it was 3.13.15.

### Removed

- `rowstile review --json` no longer has `tests.invariants_removed`, which nothing printed: Risk's flag "an
  invariant removed" names each one.
- The Python SDK's helpers that its modules share are no longer public names: `rowstile.literal`,
  `call_problem`, `check_problems`, `key_text`, `key_shown`, `explain_rule_args`, `explain_rule_sql` and `answer`
  now start with `_`, and `key_text` and `key_shown` are one. `verdict()` and the rest of `rowstile.__all__` stay.
- A test's name is written in double quotes only, as the docs show it: `test "owners see their folders"`.
  `test owners see their folders` and `test 'owners'` are refused, with the line to write instead (AZ101), and
  VS Code no longer colours them as a test's name.
- The parser no longer knows `update cols check :`, the old way to write `update cols after :`. A column named
  `check` is now a column like any other: `update check : seal` is a rule on it (it was refused, with advice to
  write `update after :`). The review and the error pages no longer speak of `role x`, `roles : ... grant` or
  `check`. In VS Code, `check` in a rule is no longer coloured as a word of the language, and an `app role` line
  typed under an indented one moves back to the margin, as a `type` line does.
- The SDKs read an error's code (`error_code()`, `errorCode()`) from `rowstile help AZnnn` in its hint alone: no
  longer from `[AZnnn]` at the end of a message, which only errors from applying a policy carry.
- The command no longer takes names no doc gave: `-d` for `--db`, `rowstile version` (`--version`),
  `rowstile help codes` (`help errors`), `--as nobody` and `--as ""` (`--as anyone`), and `python`, `typescript`
  and `ts-sdk` in `[clients]` in `rowstile.toml` (`py` and `ts`).

### Fixed

- The app role reads none of rowstile's views, and of the rules' functions it calls only those that explain them.
  It could read views and call functions that told what the rules hide: with `can view = folder.view and not
  {confidential}` on files, the view of `folder.view` on files listed the confidential files in the folders a user
  may view; with a deny inside inheritance (`(viewer or parent.view) and not hidden`), the view of what the
  permission gives before the deny listed the hidden folders shared with the user, and its function answered for
  any folder; a condition that reads another table answered for any row the caller made up. The views and functions
  the rules use are now in `authz_int`: the rules use them, and the app role can't name them (Postgres keeps a rule
  as it was read when the policy was applied, and checks a schema's privilege only when a name is looked up). The
  rules' explanations (`authz.explain_rule`, the message of a refused write) answer for a new row or one the user
  may select, and say no to all of it for any other. A rule on a column is checked in its trigger's `WHEN`. Code
  that read an `authz_gen` view now gets `permission denied`: `authz.list` answers what it asked.
  ([GHSA-2f72-cq6g-h9m4](https://github.com/rowstile/rowstile/security/advisories/GHSA-2f72-cq6g-h9m4))
- A rule condition with a quote that Postgres reads as part of a string or a name (`E'it\'s'`, `$$it's$$`,
  `"o'neil"`) before a subquery now runs with the policy's rights, as any condition that reads another table
  does. The quote was read as the string's end, the subquery was missed, and the condition ran as the app role:
  through the other table's row-level security, a `not exists` there could show rows `authz.can` refused. The
  check that inheritance doesn't depend on the time missed `now()` after such a quote too.
  ([GHSA-2868-c9qv-j9wp](https://github.com/rowstile/rowstile/security/advisories/GHSA-2868-c9qv-j9wp))
- A rule's condition that calls a function of the app's named with a letter past ASCII (`{not app.muté(this.id)}`)
  runs with the policy's rights, as one calling `app.muted` does. It was read as no call, so the app role ran
  it, and the function read other tables through their row-level security: the app role could see rows
  `authz.can` refused.
  ([GHSA-ppqr-xfwr-697p](https://github.com/rowstile/rowstile/security/advisories/GHSA-ppqr-xfwr-697p))
- Where the SDKs write the sign-in into the statement (Python: the asyncpg adapter, SQLAlchemy with a driver of
  another parameter style, `act_as_sql()`; TypeScript: `actAsSql()`), an id holding a backslash stays one
  string when `standard_conforming_strings` is off. An id such as `x\'); SELECT ...` ended the string early, and
  the rest ran as SQL. Such a value is now written `E'...'`, its backslashes doubled.
  ([GHSA-fh85-46x2-p9g2](https://github.com/rowstile/rowstile/security/advisories/GHSA-fh85-46x2-p9g2))
- A statement on a partition, or on a table that inherits, runs the triggers of the table above. Moving a
  folder through a partition of the folders' table (a tree's table without rules), adding a link row to a
  partition of a link table, or changing a row a condition reads there left the inheritance tables and shares as
  they were, so users kept seeing what the move took away. Each partition and table that inherits now gets the
  triggers; `authz.lint()` names one made since the policy was applied, and the app role's TRUNCATE on a
  partition of any table rowstile watches.
  ([GHSA-4fm2-mjhf-rp88](https://github.com/rowstile/rowstile/security/advisories/GHSA-4fm2-mjhf-rp88))
- `authz.revoke_link` judges a link given in several relations as things are before it goes, and turns it off in
  all of them or in none. It took the link out of one relation at a time and judged the next on what was left: a
  user whose access came by that link was refused in the second relation once the first was gone, and taking it
  from the first could let a user turn it off in a relation they could not unshare when they asked.
  ([GHSA-v8x5-47x7-g86r](https://github.com/rowstile/rowstile/security/advisories/GHSA-v8x5-47x7-g86r))
- `authz.explain` with the signed-in user's own id answers as without one. For a folder user 3 can't see,
  `authz.explain('folder', 6, 'edit', '3')` as user 3 showed its rule and the parts it reads (`parent is a
  folder you can't see`, `yes  {inherit}`), where a missing folder showed none of that; it now says
  `no   you have no access to folder 6`, as for a missing one. Explaining another user's access with a scoped
  key now needs a scope that names the permission, as `authz.who` does, and reads that user's access with
  their full rights, not the key's scopes.
  ([GHSA-g6j3-fff4-c8hj](https://github.com/rowstile/rowstile/security/advisories/GHSA-g6j3-fff4-c8hj))
- `authz.explain` says "you" to a service signed in as itself, as it does to a user: a relation from a column
  read `bot: bot_id is` and stopped there, and a share `viewer: shared with`. It now says `bot: bot_id is you`.
- `authz.who` asked about an id that isn't one of the type's (`authz.who('doc', 'abc', 'view')` for a numeric
  key) put back neither the caller's scopes nor its principal type, nor signed again, so the rest of the
  transaction ran as someone else or, for a role that isn't the policy's owner, was not believed (AZ702).
  `authz.explain` for another user left that user signed in the same way. Only administrators get that far
  (the app role may not inspect such an id): both now put the caller back, as they do for any other id.
- A user whose id holds `:` or is `nobody` is now written `user:<id>` (`user:service:1`) wherever rowstile names
  who acted, and reads back as that user: in the SDKs (`Principal.parse(str(p))` in Python,
  `parsePrincipal(describe(p))` in TypeScript), the audit trail, `created_by` (shares, links, custom roles,
  reviews), `decided_by` (requests, reviews), what `authz.login_key` and `authz.login_jwt` return, the
  invariants' `user_id` and `rowstile diff` (its rows and `--users`). The user whose id is `service:1` was written
  `service:1`, as service 1 is, and read back as service 1; the user whose id is `nobody` came back as nobody.
  Other users are still their id (`42`), and other principals `type:id`.
  ([GHSA-g6h7-6vfr-xm67](https://github.com/rowstile/rowstile/security/advisories/GHSA-g6h7-6vfr-xm67))
- The decision log (`authz_debug.log_decisions`) named a service by its bare id, as if it were the user with that
  id. It now names who asked as the audit trail does: `service:7`, `user:service:1`.
- Every `authz.*` function that takes an object's id now takes it as the key's type too, as `authz.can` did:
  `authz.share('folder', 1::bigint, 'viewer', 'user', some_uuid)` said "function does not exist" where users
  have uuid keys, and so did `unshare`, `create_link`, `create_role`, `roles_of`, `request_access`,
  `break_glass` and `start_review` given a uuid. A policy whose keys are all text no longer gets their bigint
  versions.
- `authz.roles_of('org', '007')` listed none of org 7's roles: it compared the id as written, where
  `authz.create_role` stores it as `7`. It now reads it as `authz.can` does.
- `authz.decide_request()` with nobody signed in (a backend that forgot to sign in, an operator in psql) said
  "you cannot decide your own request". It now says "sign in to decide a request" (AZ714, a 401 in the SDKs).
- `authz.sync_members()` given NULL for the list removed every member of the group (a sync job's failed fetch
  emptied the team), and a NULL in the list failed with Postgres's not-null error from the app's table. Both are
  now refused, saying to list the members with no NULL (AZ710, a 400 in the SDKs); an empty list still means none.
- A mask that goes gives the app role back the SELECT it had on the column. Where the app role read the table
  column by column (`GRANT SELECT (id, body)`) and a mask took `body`, removing the mask, by applying, by a
  migration or by `rowstile remove`, left `body` unreadable: only a table-wide SELECT was given back. And a
  table-wide SELECT given back by applying no longer leaves beside it the column grants the mask gave instead.
- An app role named with capitals works. `app role AppUser` names the role `"AppUser"`, as written, as a
  table's name is. The rules and grants went to `appuser` (Postgres reads an unquoted name in lower case),
  while masks and the named tests looked for `AppUser`, and failed with "role ... does not exist".
  `authz.connection_check()` didn't find a connection's role named with capitals, and said nothing of it.
  `rowstile init --role AppUser` quotes the name in the `CREATE ROLE` it says to run. A policy that names a
  role made without quotes (`CREATE ROLE App_User` makes `app_user`) writes it in lower case.
- An app role that is the policy's owner, or a member of it, was not reported: its sessions are believed without
  a signature, and it may read rowstile's tables and turn row-level security off. Applying now refuses an app
  role that is the role applying the policy, or a member of it (AZ624), where applying as that role stopped on
  `permission denied for table masked_columns`. `authz.lint()` and `authz.connection_check()` report one that
  became a member since.
- `authz.lint()` and `authz.connection_check()` said nothing of an app role that owns a governed table once the
  table had `FORCE ROW LEVEL SECURITY`, which lint's own message advised. An owner may turn row-level security
  off again: both now report it either way, and lint says the app role must not own the tables.
- Applying and `rowstile remove` know rowstile's own row-level security policies by the comment that marks
  them, not by their names. An app's own policy named `authz_select` (or `authz_insert`, `authz_update`,
  `authz_delete`) was dropped as rowstile's, without a word, and `authz.lint()` didn't report one on a governed
  table. Now it stays, and lint says it isn't rowstile's.
- Applying warned only of foreign keys `ON DELETE CASCADE` on a table with rules. It now also warns of `ON DELETE
  SET NULL` and `SET DEFAULT`, and `ON UPDATE SET NULL` and `SET DEFAULT`: Postgres runs these without row-level
  security too, so deleting a row (or changing its key) can change rows the user may not change. The warning says
  which action and what it does, and asks for `RESTRICT` (where it said `ON DELETE RESTRICT`) or a `cascade from`
  line. `ON UPDATE CASCADE` stays quiet: the row still names the same row.
- `rowstile remove` left the app role its USAGE on schema `authz` and its EXECUTE on `authz.ctx` and
  `authz.link_hashes`, which applying gives. It now takes them back: after removing, every privilege is as it
  was before the first apply.
- `rowstile remove` ran over a policy a newer version of rowstile applied, though an older command doesn't
  know everything a newer one makes and would leave some of it behind. It is refused now (AZ616), as `apply`,
  `push` and `migrate` are, unless told `--downgrade`.
- The command said "no policy is applied" (AZ609) whenever the database lacked an `authz.*` function it called,
  though a policy was applied. Now that message is only for a database without one. A policy another version of
  rowstile applied, without the function as this command calls it, is said with that version's name and
  `rowstile reapply` (AZ626, new), or "upgrade the rowstile command" when that version is newer (AZ616). A name
  rowstile doesn't make, or arguments no function takes (a typo in `rowstile sql`), is said in Postgres's words.
- A new version of rowstile that changes only what the app role is granted, or only an inheritance tree's
  functions (a message, an error code), is the next migration. Before, `rowstile migrate --check` said there was
  nothing to do, and a database set up by its migrations kept the old grants or messages. A tree's functions are
  replaced in place: the tree keeps its rows.
- A schema migration can drop a column no rule reads from a table with write rules. After the policy was applied,
  Postgres refused to drop any column of such a table ("cannot drop column ... because other objects depend on
  it"), and its hint, `CASCADE`, would have dropped the table's insert and update policies. The functions that
  explain a refused write, and the policies that call them, named every column of the row; now they pass the
  whole row and name only the columns the rules read. A column a rule reads still can't be dropped before the
  policy stops reading it.
- Inheritance trees whose names are longer than Postgres keeps (63 bytes; the tree is named after its types and
  relations) work like the others. A migration that rebuilt one whose conditions read another table failed
  ("cannot drop desired object(s) because other objects depend on them"), and one that swapped in a tree built
  beside failed ("already exists"). Applying rebuilt such a tree each time, under its lock, where it keeps the
  others that didn't change. And `rowstile indexes` advises a name Postgres keeps for an index on long names, so
  it finds, and says to drop first, what a failed `CREATE INDEX CONCURRENTLY` of it left unfinished.
- In a tree whose inheritance conditions read other tables (`{not exists (select 1 from app.frozen ...)}`), every
  statement on the tree's own table checked those conditions again on every row of the type, under the type's
  lock: renaming a folder waited for a folder's move in another transaction. Such a statement now checks them again
  only when a condition reads that table itself (the folder above's columns, say), and only if it wrote a row.
- In a tree of several types, moving a link in its table (an `UPDATE` of a placement) refreshed what was below the
  new link, then what was below the old one: twice the work, and two entries in the change feed. It is done once.
- A condition with a string or a comment that names `authz.uid()` (`{note <> 'set by authz.uid()'}`) compared
  with another string in `authz.can`, `authz.list` and the rules: rowstile rewrote the call inside the string
  too. Only the condition's code is rewritten now.
- A condition that names a column of its row in two cases (`this.ID` and `this.id`) inside a subquery failed
  with `column reference "id" is ambiguous`. Both are one column now, as Postgres reads unquoted names.
- A condition that limits inheritance and reads another table could call `age(x)` with one argument, which
  counts from today: the stored inheritance went stale without a word. It is refused (AZ305), and so are
  `current_schema`, `current_catalog`, `current_database()`, `system_user`, `random_normal()`,
  `gen_random_uuid()`, `uuidv4()`, `uuidv7()`, `authz.principal()`, `pg_backend_pid()`, `txid_current()` and
  `pg_current_xact_id()`. The language reference and AZ305's page list all it refuses. A column named like one
  of these functions (`now`, `random`) is no longer refused.
- Conditions and tests that name a column with a letter past ASCII, unquoted, read it as Postgres does
  (`{not archivé}`, `SELECT année FROM ...`): `rowstile apply`, `migrate`, `push` and `test` stopped with a
  Python traceback (`AssertionError`), and nothing was applied. `this.étage` names the row's column (applying
  stopped: `missing FROM-clause entry for table "this"`), the hint for `d.archivé` names the whole column (it said
  `d.archiv`), the warning on a bare `archivé` that a subquery's table takes is given (it was missed), and
  `ARCHIVÉ` is the column `archivÉ`, as Postgres folds only ASCII letters to lower case.
- `{size > ٣}` compared size with the number 3; Postgres reads `٣` as a column's name. Only the digits 0 to 9
  make a number now.
- A condition may hold `/* ... */` comments, as Postgres reads them (nested, over several lines): an apostrophe
  or a brace in one was read as a quote or the condition's end, and the policy refused with "a { condition is
  missing its closing }". A `$` inside a name (`total$$`) no longer opens a dollar quote either.
- Parentheses that change nothing no longer get an inheritance refused. `can view = owner or (parent.view or
  owner)`, or `((owner or parent.view) and {inherit}) and not hidden`, was refused as depending on itself (AZ302)
  or as narrowed with more than conditions (AZ304). They are now read as if the parentheses weren't there.
- A deny may inherit on the same conditions as the permission it takes away, written in another order, or on
  fewer of them: `can hidden = ... or (parent.hidden and {inherit})` beside `(parent.view and {not archived} and
  {inherit})` is taken. Where its conditions differ otherwise (`{INHERIT}` for `{inherit}`), the message shows
  both: it said the deny must inherit through `parent`, which it did.
- A mistake after the first word of a line at the left margin says how that line is written:
  `type folder app.folders` gets "write types as: type name = schema.table [(key)] [principal] [where {sql}]", and
  `include roles.authz` is told to put the file's name in double quotes. Each such line was told it didn't start
  with `app role`, `type`, `rules`, ... although it did.
- A permission line takes a tab after `can`, as every other line takes one between its words. It was read as a
  relation and refused ("write relations as ..."), and `rowstile fmt` refused the file.
- A block ends at an include line and at the end of its file. An included file's first lines, indented, went on
  with the block before the `include` line, and indented lines after it with the included file's last type: they
  are now refused as outside a block. An indented `include` line says it must start at the left margin (it was
  refused as a relation).
- A missing included file is reported as `can't find teams.authz in the policy's folder`, with the name it
  looked for from the policy's folder. The command said to "pass it in the files argument", which it has no
  such thing as.
- A policy that includes a file named with an apostrophe (`include "o'brien.authz"`) failed to apply with
  a bare syntax error. It applies, and the messages that name the file's lines say its name as written, a `%` in
  it too. A file whose name holds a dollar quote's tag (`$f$`) can't be included: the include line is refused,
  saying to rename the file (AZ108).
- A test line names a scope as the `scope` line declares it: `with scope files:write` and `with scope read-only`
  were refused ("a test's lines are ..."). The editors read such names too.
- A test with an empty name (`test ""`) is refused, and words after a test's closing quote are said to be the
  mistake (it said the quote wasn't closed).
- `as ... sees N {...}` refuses a statement that writes after a comment or in its `WITH`
  (`WITH gone AS (DELETE ...) SELECT ...`), as it refuses one that starts with `DELETE`. `rowstile test` failed it
  with Postgres's error.
- `rowstile check` (the MCP server's `check` too) and the editor report a mistake in the policy's own test
  lines, as `rowstile test` does: a test naming a type, a permission or a scope the policy doesn't have read as
  `ok` there.
- Error pages and messages say what the compiler does. AZ302 no longer calls a permission inheriting across
  types (projects and folders inside each other) a mistake; AZ306 says conditions may join the inheritance
  beside the deny; the error codes' index says that an error the app meets at run time carries its code in its
  HINT, not at the end of the message. AZ502 names the types that sign in without "one of" a list of one, and
  messages no longer say "a org".
- `rowstile fmt` lays out a condition whose string, quoted name or dollar quote goes on to a line that starts
  with `--`: that line is in the quote, not a comment. fmt refused such a policy, saying formatting would change
  what it says. And a run of spaces inside a quote counts: the lock file's lines, and fmt's check that it
  changes nothing, read `'a   b'` and `'a b'` as two things.
- `rowstile prove`'s counterexample, and the world the review shows when a change is no refactor, say what the
  world holds as you would make it. A share to `user:*` read as a share to one user (`folder 1 -> user 1`); it
  reads `folder 1 -> user:*`. The rows each type's `where` keeps are said (`{active} holds for user 1 (the type's
  where)`), and making the world smaller no longer takes away the value a kept row needs (`active = true`): the
  user shown looked suspended. The custom roles given are listed (`doc.roles with view: doc 1 -> user 1`), and
  `anyone` reads `anyone`, not `anyone *`. The review's world is made as small as it still grants otherwise in,
  as prove's is: no link that plays no part. "after 1 worlds" reads "after 1 world".
- `rowstile prove` and the review read two texts compared with one column as two values, so
  `{status = 'Public'}` and `{status = 'public'}` never held on one row there. A column under a case-insensitive
  collation holds both, and prove said an invariant held that the data broke. Texts a column may hold as one
  value (the same but for case, accents, spaces or punctuation; two that name numbers or dates; letters past
  ASCII) are now left to the database there, as a subquery is: prove draws the rows each holds for, and the
  review says it can't compare a change between them. Different words (`'draft'`, `'published'`) are still read
  as two.
- `rowstile review` flags more of what widens access. A rule that reads a relation's permission itself
  (`insert : folder.edit`) changes through that relation, as `select : view` does: repointing `file.folder` to
  another column now flags who may insert. A `shared if` removed or changed, and a caveat changed, are flagged.
  A plain `update after` removed is no longer called a column rule: it is flagged where the `update` rule, which
  then checks in its place, lets more rows through; a new one is flagged where it lets more through than
  `update` did.
- `rowstile review`'s Deploy names the tables a migration finds only as it runs, and the mode it locks them in:
  the tables an inheritance condition reads, and the partitions and child tables of the governed ones. It said
  "Locks `app.folders`" while the migration also locked `app.settings`, which a condition read.
- The comment `rowstile review --markdown` writes shows Meaning's example when a change thought a refactor isn't
  one: what differs, for whom, on what, and the world that shows it, as the text output says. A failed test
  without a line or a detail reads `- fails: a test`, not `- fails: a test : ` and two backquotes.
- `rowstile review` checks a change that looks like a refactor in seconds on a policy with many types. The small
  worlds it lists counted rows of every type, also those the change doesn't read: with 14 types, a permission
  rewritten as `owner or owner` took almost four minutes, and each more type about four times as long. Only the
  types the change reads vary now, and the listing gets further in the same number of worlds.
- The review's GitHub action passes on a pull request from a fork. GitHub gives such a pull request a read-only
  token, so the comment was refused and the job failed. Now the review is in the run's summary, and a notice
  says so.
- A review longer than a comment may be is cut, and the comment says where the whole review is: the run's
  summary on GitHub, the job's artifact on GitLab. GitHub refused a comment over 65,536 characters, and the
  GitLab job failed ("Argument list too long") on a review over 128 KiB.
- The GitLab template's header said a top-level `ROWSTILE_VERSION` picks another release. GitLab gives the job's
  own variables first, so it was ignored. It now shows how to set it, and the stage, in the job, and says to set
  `ROWSTILE_REVIEW_TOKEN` in the CI/CD settings, not in the file.
- `rowstile init` read the columns a primary key or unique index INCLUDEs as part of the key. A table with
  `PRIMARY KEY (id) INCLUDE (title)` was drafted as keyed by `(id, title)`: a users table so declared was refused
  (AZ622), and foreign keys to such a table gave no relation. `authz.lint()` likewise said the app role may choose
  a primary key the database makes when it may write a column the key's index INCLUDEs. Both read the key's own
  columns now.
- `rowstile indexes` and `authz.lint()` counted an index's INCLUDE columns as if the index were sorted by them.
  An index on `(parent_id) INCLUDE (parent_type)` was said to serve a lookup by `(parent_type, parent_id)`, so a
  lookup with no index could go unnamed. Only an index's key columns count now.
- `rowstile init` stopped with a Python traceback (`KeyError`) when the table the columns naming users point to
  wasn't among the drafted ones: in another schema (as Supabase's `auth.users`, with `--schema public`), or left
  out for its name. It now says which table, which columns point to it, and what to do: draft its schema too,
  or name the table with `--users`.
- `rowstile init` notes that a membership's `permission` or `permissions` column may say who does more, as it
  did for `role`, `kind`, `level` and `access`. `rowstile init --help` says it drafts from every schema of the
  app's when `--schema` names none (it said `public` only).
- `rowstile init --out` refuses an absolute path or one outside the folder, before writing anything (exit 2):
  every later command refused the `rowstile.toml` it wrote. A folder name holding `"` or `\` is written
  escaped, so `rowstile.toml` still reads.
- `rowstile init` finds goose, dbmate and Flyway: their markers in a migrations folder's files, Flyway's names
  (`V1__init.sql`), or the folder `flyway.toml` or `flyway.conf` names. It took them for plain SQL, and the
  files `rowstile migrate` then wrote were refused or skipped. Files named for a tool rowstile writes none for
  (`1_init.up.sql`) leave `[migrations]` out of `rowstile.toml`, and init says so. It reads Drizzle's
  `out: "../shared/drizzle"` as written (it read `shared/drizzle`, and a key ending in `out`, `layout:`, as
  `out`), and marks a migrations folder that is `rowstile.toml`'s own `/*_authz_*` in `.gitattributes`
  (`./*_authz_*` matched nothing).
- `rowstile migrate` for goose, dbmate and Flyway names its file with the number after the folder's last when
  that one is numbered (`00003_`, `003_`, `V3__`), as it did for plain SQL. It used the time, and the app's next
  migration, numbered after its own, then came below one applied already: goose, Flyway and `dbmate --strict`
  refused it. Plain SQL files take the time after a folder whose last file starts with the time.
- `rowstile sql --as WHO "COPY t FROM STDIN"` waited for good, with a transaction open on the server. The copy now
  fails at once: "COPY from stdin failed: the rowstile command sends no rows to COPY FROM STDIN (psql's \copy
  does)".
- An empty `--db` (a script's `--db "$DATABASE_URL"` with the variable unset) stopped with a Python traceback.
  It now says `--db is empty`, exit 2, as an empty value of any option does.
- The command connects as libpq does where it didn't. `sslmode=prefer` (the default) tries again without TLS when
  TLS fails (a `~/.postgresql/root.crt` that didn't sign the server's certificate) or the server refuses the
  session over TLS. `sslmode=allow` tries without TLS first. `connect_timeout=0`, or less, waits as long as it
  takes (it meant 10 seconds, and `-1` was refused). What still differs is named in the tools reference: no
  password file, 10 seconds where `connect_timeout` isn't given, and no client certificate.
- The command's connection messages: a port out of range (`postgresql://h:70000/app`, `port=0`) is said as such
  (a URL's was blamed on a `#` in the password). A password stays out of them: a refused setting that holds a
  secret (`scram_client_key`, `scram_server_key`, `oauth_client_secret`) is named without its value, and the rest
  of a password with a space in it, unquoted (`password=my secret`), isn't repeated. When the server asks for a
  password and none was given, the error says where to give one, and that the command reads no password file
  such as `~/.pgpass`.
- When the server closed the connection without a word (it crashed, a proxy dropped it) while a statement was
  on its way to it, the command said `lost the database: [Errno 104] Connection reset by peer`. It now says
  `lost the database: the server closed the connection`, as it does when the server closes between two
  statements. When the server said why first (the session was ended, it is shutting down), those words are
  still what the command says.
- The MCP server (`rowstile mcp`) answers a call whose arguments a tool refuses (one missing, null, or one that
  reads as an option, such as `--development`) with the tool's failed call (`isError`, exit code 2, the reason in
  its text), as MCP 2025-11-25 asks, so that the agent sees why and corrects the call. It answered with a protocol
  error, which a client may keep from the agent. A call whose `arguments` isn't an object is a protocol error now,
  where the tool ran as if it had none.
- The language server checks an open test file again when the policy changes: renaming a permission in the
  policy marks the test lines that still name it, where they kept their old diagnostics until the test file
  itself changed. A mistake in the policy, seen from a test file, is said on the test file's first line with the
  policy's file and line (`policy.authz line 7: ...`), where it sat on the test file at the policy's line. It
  clears a closed file's diagnostics, which an editor kept showing, and checks the open files again when the
  policy's file is closed with changes not saved. Find references searches the policy's included files and the
  open test files, not only the file it is asked in.
- The language server counts columns as editors do (UTF-16 code units): after an emoji on a line, hover,
  completion, go to definition and the underlined words were one column off. A message it can't read (a body
  that isn't JSON, a `Content-Length` that isn't a number) is answered with a parse error, and the server goes
  on. It ended, and the editor lost errors and completion.
- The editors read more policies as the compiler does. Zed, Helix and Neovim showed a parse error on a condition
  holding `"a}b"`, `"it's"`, `E'it\'s'`, `$$}$$`, a `/* } */` comment, or a `--` comment with a brace or an
  apostrophe in it; on a column named `before` or `after` (`update before before : edit`, as the compiler's own
  message suggests); and on a test id with a `$` inside (`user a$b can view file 1`). In VS Code and on the site,
  `before` and `after` at the end of an update rule's columns are coloured as words of the language, not as
  columns; `test` and `invariants` followed by a comment keep their colour; and `user:*` (any type's), `principal`,
  `include "roles.authz"`, a link table's name with its `object:` and `subject:`, and test lines whose id is
  quoted with a space are coloured. VS Code moves `type`, `rules` and the other first words back to the margin
  when typed on an indented line, and closes `[` and `"`.
- The VS Code extension builds from the repository as its page says (`npm run package` in `editor/`): it
  stopped on a missing `LICENSE`. The link on its Marketplace and Open VSX page, to installing the command, leads
  to that page again. When the language server doesn't start, the extension (0.1.3) says why, and how to install
  rowstile or set `rowstile.command`, where it only said it couldn't connect. A change to `rowstile.command`
  starts the server again with it; it needed a window reload.
- The editors' page says how to point VS Code and Zed at a `rowstile` installed in the project (npm's
  `node_modules`, a `.venv`): such an install isn't on the PATH the editor starts the server with. Its Neovim
  steps highlight: they now build the grammar, put it where Neovim looks and start highlighting, and say
  Neovim 0.11 or newer. Paths into the repository say `core/cli/`, and Sublime Text is no longer said to read
  the TextMate grammar as it is.
- Studio's grid showed a table's rows in the order of their ids as text: with numbered rows, 1, 10, 100, 101,
  ... 11, page after page. They now come in the key's own order, 1, 2, 3. Studio listed the tables, so two types
  over one table (a table with no rules may be read as several) showed as one, with one type's permissions under
  the other's name. It now lists the types, each with its table.
- In a Studio that can write (`--write`, `rowstile dev`), why and the access diff ran in a transaction that was
  committed, though each change they try is undone. They are now rolled back whole: nothing they try stays.
- `rowstile why` and Studio listed a change both as the best way to grant a permission and as "could not be
  tried", when the change grants it but counting what else it gives failed (a condition that fails on another
  row, say). It is now listed only as not tried, with the database's reason: what else it gives was never counted.
- Studio's page: in the Tables tab each row's cells sit under their headings again (each row was laid out as a
  flex box, its cells bunched apart from the columns). "Why?" while viewing as anyone says to pick someone,
  where it showed "Asking…" for ever. Clicking a type or a permission in the graph shows how it is written
  (nothing happened). The page asks for the policy again when a tab or a table is opened, so under
  `rowstile dev` a permission added or renamed since the page opened is offered. The shares show a custom
  role's name (not `role:<id>`), a caveat, and when a share starts; a request shows for how long approving
  gives it. A share link has no Unshare button: it removed nothing and said "Done". The page says
  `authz.revoke_link` turns a link off, and Studio refuses to unshare a link. The graph uses the playground's
  Mermaid (12.0.0), checked against its hash.
- The generated Python client named each type's permissions with its name in lower case after the first letter:
  `orgUnit` gave `OrgunitPermission`, and two types whose names differ only in case, `doc` and `Doc`, both gave
  `DocPermission`, the second replacing the first. A type's alias now keeps its name as written
  (`OrgUnitPermission`), and two types that would get the same one get none, with a comment that says why.
- Both SDKs read Postgres's own refusals for what refused. An update after which the user could no longer see
  the row was a 403 that spoke of reading an insert back; it now says the user may not see the row as written
  (the select rule). In Python, an upsert (`INSERT ... ON CONFLICT DO UPDATE`) of a row the user may not change
  named the select rule; it names the update rule, as in TypeScript. A `MERGE` that matched a row the update or
  delete rule hides was no refusal at all (a 500); it is a 403 with no command, since Postgres doesn't say which
  rule. And in Python a refusal by a restrictive policy rowstile didn't make is no longer read as the select
  rule's: it stays the database's error, as in TypeScript.
- TypeScript: inside `transaction(fn, who)` (`@rowstile/pg`, `@rowstile/drizzle`) and `begin(fn, who)`
  (`@rowstile/postgres`), the object's own calls (`a.expect`, `a.can`, `a.share`, `a.query`, ...) run in that
  transaction, as `who`, and `fn` acts for `who`. They ran in a transaction of their own on another connection,
  signed in as whoever the code around acted for (or the `user` function, or nobody): `a.expect` gave the reason
  for someone else, nothing saw what the transaction had written, and on a pool of one they waited for ever.
  ([GHSA-3vph-6725-7vhw](https://github.com/rowstile/rowstile/security/advisories/GHSA-3vph-6725-7vhw))
- `@rowstile/prisma` reads a compound key's fields in the key's order, which its name gives
  (`project_id_user_id`), not in the order the `where` lists them: `{ user_id: 2, project_id: 1 }` was asked
  about row `(2,1)`, so an update could be a 404 where it is a 403, or name the wrong row. A key given a name of
  its own (`@@id(name: ...)`) names no row unless `authz({ keys })` gives its fields.
- `@rowstile/drizzle` on node-postgres listens for a lost connection while a transaction holds one, as
  `@rowstile/pg` does: a database that restarts mid-transaction fails the transaction, where it stopped the
  process.
- `@rowstile/react` works in a Next.js server component, such as `app/layout.tsx`: the package is a client
  module (`"use client"`). Rendering `<AuthzProvider>` or `<Can>` there failed the build, which asked for
  `"use client"` in a file of the app.
- `rowstile.fastapi` with no engine, `Rowstile(app, None, user=...)` (an app on psycopg or asyncpg without
  SQLAlchemy), answers the drivers' errors as it answers SQLAlchemy's: a refused write 403, and each code as its
  page says. They were a 500.
- `rowstile.fastapi` answers an ORM update the rules allow that matched no row (the row changed since it was
  read: a version counter) with 409, where it answered 404 "the row not found". Where it can't tell (a model
  mapped to a join), it leaves the `StaleDataError` to the app.
- A refused ORM update is explained from the flush's own transaction, before it is rolled back. A row that
  transaction had written answered 404, since another transaction can't see it; with a pool of one connection
  that the request's session still held, the answer waited for the pool and failed with a 500. A flush of more
  than 20 rows of a table was asked about its last 20 only (a 404 when the refused row came earlier), one query
  each: every row is asked about now, in one statement.
- `NotFound()` without a table says "not found", and `NotFound(id_=7)` "row 7 not found" (it said "the row not
  found").
- `rowstile.alembic.include_object` said it left out the masked views rowstile makes. It leaves out a model whose
  table says so, `info={"rowstile": True}`: the FastAPI page and the SDK's README now say to mark a model of a
  masked view that way.
- The Python SDK's docs no longer offer `pytest_plugins = ["rowstile.testing"]`, which stops pytest once the
  package's entry point has loaded the fixtures. `ids()` says a uuid key takes `key_type=Uuid` (with `None` the
  ids are text, which a uuid column can't be compared with), and that a key of several columns can't use it.
- The npm launcher asks the Python `ROWSTILE_PYTHON` names for its version first, as it asks the one on `PATH`:
  one older than 3.11, or a path that isn't a Python, is refused with a sentence, where the command failed
  inside. A bundled Python that isn't executable and can't be made so (a `node_modules` another user
  installed) is said to be so, not to be missing. `ROWSTILE_PYTHON` has its line in Installing and
  Troubleshooting.
- The packages hold the command's files and nothing else: the npm package's build copied `core/authzlib` and
  Studio's folder whole, and the Python package's wheel and sdist took any file beside them, so a file left
  there (a note, an editor's backup) went in. Both now take the files one list names. A release publishes on
  PyPI and on the VS Code Marketplace the files its GitHub release attaches and attests (the wheel, the sdist
  and the `.vsix` were built a second time for those), and a patch to an older line no longer becomes the
  repository's latest release on GitHub.
- The tools reference lists every option each command takes (`migrate --tool --dir --one-phase --downgrade`,
  `diff --limit`, `bench --people --rounds`, `init --role --out`, `snapshot --out`, and the others), every
  `rowstile.toml` setting (`[migrations] lock` and `write_after`, `[review] snapshot`, `[clients] ts`), the exit
  codes, and which folder `migrate --dir` and `--out` are read from. `rowstile --help` names `review`'s policy
  argument and `[review] snapshot`, and says which policy `graph` draws.
- The reference's list of the generated Python client's calls left out `sign_in_as`, `principal`,
  `connection_check` and the API key calls, and it said the TypeScript client had the same calls, which it
  doesn't quite (no `principal`, signing in with `asUser`). It now lists each client's calls, and which calls the
  TypeScript SDK has. Its table of functions names `authz.perms_of` and `authz.connection_check`.
- The policy language page's example applies as written: its `shared if` condition had `...` in it, which no
  database runs. It says what an include may name (a file in the policy's folder, once). The identity page and
  the threat model name `view_as` among what signs a session in; the identity page no longer says the SDKs sign
  in with a key. The operations page says to make the roles first when restoring on a new server (`pg_dump`
  keeps none), and the OpenFGA and SpiceDB pages name the line their policy needs before its editors can be
  shared.
- The docs didn't say that a write rule checks each row against the tables as the statement found them, so a
  count in a rule is no limit on how many rows there may be: with `insert : {(select count(*) ...) < 2}`, one
  `INSERT` of three rows writes all three. The limits page says so now, and what to use instead (a unique index,
  or a trigger). The messenger example relied on such counts: one `INSERT` could put three people in a direct
  chat, or two owners in a new group. Its schema now holds both.
- The stack pages' code no longer takes the signed-in user from a request header. The Next.js and FastAPI
  pages showed the conformance apps' stand-in, a header any client can set; they now show the user coming
  from the app's session (`auth()` in Next.js, the app's own `session_user` in FastAPI). The Next.js page's
  install line has `@rowstile/pg`, which its live updates import, and the FastAPI page's code imports `os`
  and `rowstile`, which it uses.
- Three cookbook recipes gave more access than their pages said. In roles per organization, a document's owner
  could move it into another organisation, or make one there, and its members saw it: its organisation now
  can't change (`update org_id : nobody`). In tenants, a ticket assigned to someone of another organisation was
  theirs to read and edit: the assignee now holds it only as a member (`(assignee and org.member)`), and an
  invariant says no one outside sees a ticket. The multi-tenant page says that someone in two organisations may
  move a project across, and how to forbid it. The language reference says which moves `authz.lint()` warns
  about. A policy copied from these recipes wants the same change.
- Each cookbook page said to take the recipe's files and run `rowstile dev`, which stopped at "which policy
  file?". Each recipe's folder now has a `rowstile.toml` that names its policy and its tests, and the cookbook
  says the steps: load `schema.sql` and `rows.sql`, then run `rowstile dev`. The recipes' tests now check what
  their pages say: someone with a link sees the document, a share starts and ends when it says, an approved
  request ends after the time asked for, nobody decides their own request, asking for a document that doesn't
  exist goes as asking for a hidden one, a private folder's owner keeps it, and teams count three deep and in
  a loop. `rowstile dev --help` shows that it takes a policy file.
- The page on files in S3-compatible storage (`docs/signed-urls.md`) uploads as the file manager does: the browser
  sends the bytes to a place of their own (`uploads/<key>`), and confirming the upload moves them to the file's
  object and checks their size. The page signed the upload for the object's own key: that link goes on working
  after the confirm, so it could replace a confirmed file, whose stored size was then wrong.
- The docs app's own tests (`core/example`) pass on its own data, as their header says: 3 of their checks needed
  shares that only the end-to-end scenario made, and are now a named test that makes them. The playground's docs
  example shows the policy's tests too.
- The playground goes on after an edit that follows an answer: the tests run again and the question is asked again.
  It stopped there for good, and Run did nothing until the page was reloaded. A step that fails no longer stops the
  ones after it, and an answer with a large `int8` in an array (`ARRAY[9007199254740993::int8]`) shows. Asking after
  a failed run says the policy isn't applied, not that the last policy's role doesn't exist. An answer whose
  statement ran `COMMIT`, `ROLLBACK` or `RESET ROLE` says it wasn't rolled back, or which role it ended as (after a
  `COMMIT`, the rest ran signed in as nobody). The Help pane shows an error page's examples as code. A link the page
  can't read says so until another example is chosen, and a page whose `bundle.json` doesn't load says why, where it
  said "loading…" for ever.
- The site's links to the repository's files go to the release it shows, not to `main`, where a file may have
  moved or changed since. Its headings' anchors are GitHub's (`#what-a-0x-release-promises`), so a link to a
  heading written for GitHub finds it on the site too. The card a shared link shows is drawn with fonts kept
  beside it (Inter, JetBrains Mono), so it looks the same whichever machine renders it.
- The blog post's `experiment.sql` stopped at its first query when run by a role that isn't a superuser
  (`permission denied to set role "demo_app"`): it now grants that role to whoever runs it, so a role with
  CREATEROLE runs it on a stock server too. Its header says it drops an earlier `demo` schema and
  `demo_app` role first, and to read the middle of each query's three timings, as the post's figures are.
- The file manager example: its development steps work as written, as the messenger's do (the README waits for
  the services, runs the frontend from its own folder and says `npm ci`), and its README names each setting with
  its default, the maintenance jobs to schedule and each part of the backend. `migrate.py` runs outside this
  repository: it needs the command only for `--client`, and there it runs the one installed. The app's image no
  longer copies the command, and `test.sh` takes the database and storage down when a step stops the run early.
- The file manager example's rules and API: moving a folder takes the right to share it, as deleting it does (an
  editor could move a folder into one of their own, which gave them `share` on it and took it from everyone who
  reached it from above). Two uploads committing at the same time could together pass the storage quota; the
  second now waits for the first. `FM_MAX_UPLOAD_BYTES` holds for the bytes an upload sends, not only for the
  size it claims. Its errors say what is wrong, from the constraint's name ("the folder isn't empty" was said of
  a group with sub-groups and of a member who has no account). Search pages by name then id, each list with its
  own cursor: a page that ended among equal names skipped the rest of them. The app waits for RustFS to answer
  before it starts.
- The file manager's web app shows a file's Share, Rename, Move and Delete, a folder's Rename, and a file's
  "Upload a new version" and "Make current" only where the API says the user may (`can_edit`, `can_share` in
  each listing, from `authz.can`), and a folder's Share, Move and Delete only to those who may share it: they
  showed where they could only fail. Search
  shows "More" (it stopped at 50). A share link was listed twice in the share dialog. A share or link "until" a
  day lasts to the end of that day where the person is (it ended as that day began in UTC). A request's duration
  reads "7 days", not "P7D". Cancel on "Why not?" no longer denies the request, and a preview's Download or
  "Leave this group" that fails says why.
- The messenger example: its development steps work as written (the README gives the two settings
  `db/migrate.py` needs and `npm ci` before `npm run dev`), and `migrate.py` runs outside this repository, as the
  file manager's does. An open chat loaded its messages again and again, each load marking the chat read and
  telling every member's browser to load it too: it now loads once per change. Its database is published on
  127.0.0.1 only, and its migrations, policy and tests run as the tables' owner (`ms_owner`), not the superuser.
- The messenger example's rules and API: a group's owner could leave it through the API, and the group, without
  an owner, could never be deleted; the owner now stays, and deletes the group instead. Marking a message
  "edited" without editing it is refused. An admin who opened their own group's invite link was told it didn't
  work. A negative `limit`, or a number past bigint's range, answered 500 (now 422 or 400). The chat list counts
  unread messages from their numbers (it read each one: 5.5 s for 100,000). A direct chat whose other person
  left no longer disappears from the list, and a button whose request failed says why.
- Some things only the alphas' release notes said are now in the docs: the SDKs' `not_signed_in(e)` and
  `notSignedIn(e)` (the not-signed-in error, AZ701, and not a refused login), `db.$authz.tableName()` and the
  Python SDK's `verdict(..., named=)`; the `CREATE INDEX CONCURRENTLY` that `rowstile indexes` gives goose and
  dbmate in a migration of their own, a partitioned table's index without it, and the unfinished index a failed
  build leaves, named first; that `rowstile prove --worlds N` tries more worlds than N; what `rowstile sql --as`
  says of a write that changed no row; and a key that two rows hold through a table that inherits (the limits
  page).
- A relative link in a release's notes on GitHub (`[Installing](docs/installing.md)`) led nowhere: the release's
  page reads it from its own address. The notes now link to the file at the release's tag.

## Before the beta

The alphas, from 0.1.0-alpha.1 (2026-10-04) to 0.1.0-alpha.9 (2026-10-19), were for trying rowstile early. The
first was published as rowfence; from 0.1.0-alpha.2 on the project is rowstile, as another product, a proxy for
DuckDB, had the name first. The beta starts afresh: it doesn't upgrade a database an alpha made, and it reads
none of the names from before the rename (see
[what a 0.x release promises](/reference/limits.md#what-a-0x-release-promises)). Each alpha's notes are on
its GitHub release:

- [0.1.0-alpha.9](https://github.com/rowstile/rowstile/releases/tag/v0.1.0-alpha.9) (2026-10-19)
- 0.1.0-alpha.8 (2026-10-19): tagged, and never published (its release run stopped before publishing)
- [0.1.0-alpha.7](https://github.com/rowstile/rowstile/releases/tag/v0.1.0-alpha.7) (2026-10-13)
- [0.1.0-alpha.6](https://github.com/rowstile/rowstile/releases/tag/v0.1.0-alpha.6) (2026-10-07)
- [0.1.0-alpha.5](https://github.com/rowstile/rowstile/releases/tag/v0.1.0-alpha.5) (2026-10-06)
- [0.1.0-alpha.4](https://github.com/rowstile/rowstile/releases/tag/v0.1.0-alpha.4) (2026-10-06)
- [0.1.0-alpha.3](https://github.com/rowstile/rowstile/releases/tag/v0.1.0-alpha.3) (2026-10-05)
- [0.1.0-alpha.2](https://github.com/rowstile/rowstile/releases/tag/v0.1.0-alpha.2) (2026-10-04)
- [0.1.0-alpha.1](https://github.com/rowstile/rowstile/releases/tag/v0.1.0-alpha.1) (2026-10-04), published as rowfence
