From 850e04fd6107b398c9861b349e6d469d299afcf3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Wed, 11 Nov 2026 10:36:18 +0000 Subject: [PATCH] chore(release): version packages --- .changeset/reference-consumers.md | 17 ------- .changeset/reference-repeater-contract.md | 26 ---------- .changeset/reference-store-integrity.md | 21 -------- packages/agent-runtime/CHANGELOG.md | 9 ++++ packages/agent-runtime/package.json | 2 +- packages/analytics/CHANGELOG.md | 9 ++++ packages/analytics/package.json | 2 +- packages/api/CHANGELOG.md | 62 +++++++++++++++++++++++ packages/api/package.json | 2 +- packages/astro-renderer/CHANGELOG.md | 13 +++++ packages/astro-renderer/package.json | 2 +- packages/cli/CHANGELOG.md | 28 ++++++++++ packages/cli/package.json | 2 +- packages/cloudflare/CHANGELOG.md | 25 +++++++++ packages/cloudflare/package.json | 2 +- packages/comments/CHANGELOG.md | 11 ++++ packages/comments/package.json | 2 +- packages/core-contracts/CHANGELOG.md | 24 +++++++++ packages/core-contracts/package.json | 2 +- packages/core-ts/CHANGELOG.md | 55 ++++++++++++++++++++ packages/core-ts/package.json | 2 +- packages/create-cloudhal/CHANGELOG.md | 7 +++ packages/create-cloudhal/package.json | 2 +- packages/mcp-server/CHANGELOG.md | 58 +++++++++++++++++++++ packages/mcp-server/package.json | 2 +- packages/schedules/CHANGELOG.md | 9 ++++ packages/schedules/package.json | 2 +- packages/storage/CHANGELOG.md | 24 +++++++++ packages/storage/package.json | 2 +- 29 files changed, 347 insertions(+), 77 deletions(-) delete mode 100644 .changeset/reference-consumers.md delete mode 100644 .changeset/reference-repeater-contract.md delete mode 100644 .changeset/reference-store-integrity.md diff --git a/.changeset/reference-consumers.md b/.changeset/reference-consumers.md deleted file mode 100644 index 20235544..00000000 --- a/.changeset/reference-consumers.md +++ /dev/null @@ -1,17 +0,0 @@ ---- -"@cloudhal/core-ts": minor -"@cloudhal/api": minor -"@cloudhal/cli": patch -"@cloudhal/cloudflare": patch -"@cloudhal/mcp-server": patch ---- - -The consumers of reference fields (RFC-0045 §2, rollout step 2b, #114). Both new field types stay refused on every write path in production, so none of this is reachable before rollout step 7. The shared suites run it through `SiteGraphStoreOptions.fieldTypes`. - -- **Assets inside repeater items.** `fieldAssetRefs` walks items and records `fields..` with each use's item path. `fieldAssetIssues` checks sub-field types (a PDF in an image sub-field is refused) and reports at every item that uses the file. Skips match issue paths by prefix, in the store and in the MCP precheck alike, so top-level behaviour is unchanged. -- **Field-operation rewrites** write their entries' `entry_refs` rows. A rewrite that changes a reference value is guarded on its target, and every rewrite in a site with reference fields is guarded on the collection's definitions. -- **Releases** no longer treat reference values as dependencies, so a referenced entry is neither locked nor required live. -- **Language editions** (`forEdition`) keep only what the edition's own write accepts. A reference needs a member of its group in an allowed collection that meets the field's `where`. A single-target field keeps one id, and a multiple field keeps at most `maxItems`. An entry holds at most 100 references, and a repeater at most `maxItems` items. Values are read through a running rename's old key. Everything not carried, including repeater items left empty, is reported with its reason through `onDropped`. A re-save keeps the values the edition entry already holds, as its own write would. -- **CLI.** `cloudhal import --dry-run` warns about references that will show nothing, and about originals relinked into another group. -- **Cloudflare.** `siteFieldTypeSupport` reads the site Worker's `fields` feature. `FIELDS_FEATURE_VERSION` and `FIELDS_SUPPORTED` are exported from `@cloudhal/core-ts/fields`. Nothing passes them to a store before step 7. -- **API.** `GET /sites/:siteId/entries/pick` is the entry picker. Its search folds case and diacritics on both sides with `foldName`, Turkish İ and ı included, and reads at most 1,000 entries per request. When that runs out before 20 matches, it answers `truncated: true` with a `cursor` to continue from. `GET /sites/:siteId/entries/:entryId/references` lists an entry's referrers, each with the language versions that show it. Both need `content:read`. diff --git a/.changeset/reference-repeater-contract.md b/.changeset/reference-repeater-contract.md deleted file mode 100644 index e0ce785c..00000000 --- a/.changeset/reference-repeater-contract.md +++ /dev/null @@ -1,26 +0,0 @@ ---- -"@cloudhal/core-contracts": minor -"@cloudhal/core-ts": patch -"@cloudhal/mcp-server": patch -"@cloudhal/api": patch ---- - -The contract gains two field types for collections, `reference` and `repeater` (RFC-0045 §1, rollout step 1, #114). Every write path still refuses them, so existing sites behave exactly as before. - -- **Contract.** `FieldDefinition` gains `ReferenceField` and `RepeaterField`. A new `SubFieldDefinition` union holds a repeater's sub-fields: scalar values only, so a repeater cannot contain a repeater. `FieldMigration.fromType` gains both types, and `FieldMigration` gains an optional `sub`. There is no `schemaVersion` bump, and existing documents stay valid. -- **The gate.** Until rollout step 7 enables them, a reference or repeater definition, or a migration marker that names one, is refused with `fields_unsupported`: API status 409, with an MCP hint. The refusal covers: - - site creates and updates, so Studio, MCP and the API; - - field operations; - - every bundle `importSite` takes: import, pull, push, `cloudhal import --replace` and `--revert`, snapshot restores and edition copies. - - `checkBundle` gained `assertFieldTypes`. It checks the working site row, and `prepareImport` checks every snapshot site body the import writes once it has been verified (bodies the target already holds are its own), and refuses the types when no capability is given. A push answers `409 fields_unsupported` with its issues, not `400 bad_request`. -- **Pure core** (`@cloudhal/core-ts/fields`), with no effect on stored data yet: - - the definition rules: `reference_target_unknown`, `where`, `itemLabel`, and caps on sub-fields and leaves; - - value checks for both types, the per-item `requiredToPublish`, and `too_many_references`; - - `resolveFields` skips types it does not know; - - `fieldsJsonSchema(…, { strict: true })` and `strictSchemaCost`; - - `pickMember`, `referenceIssues`, and `FIELD_QUERY_OPS` and structured-data entries that make neither type listable or mappable. - - `FIELD_TYPES` keeps the nine enabled types (`EnabledFieldType`). `ALL_FIELD_TYPES` lists all eleven. -- **MCP.** `update_collection`'s input now builds its `$defs` with `defsClosure` and offers only the enabled types. A test checks that every `$ref` in every tool's input and output schema resolves. Before this change, `pnpm gen` alone would have left the input pointing at `$defs` it did not carry. -- **Fix, existing sites:** block props and typed-field objects no longer accept keys named after `Object.prototype` members (`constructor`, `toString`, `__proto__`, …) as known props. The props interpreter (`validateProps`) now checks and reads own keys only. Such keys are refused as unknown, and a prop the value leaves out is absent, not the prototype's function. `toLocaleString`, `isPrototypeOf` and `propertyIsEnumerable` join the reserved field keys, beside `toString`, `valueOf` and `hasOwnProperty`. diff --git a/.changeset/reference-store-integrity.md b/.changeset/reference-store-integrity.md deleted file mode 100644 index 527d941a..00000000 --- a/.changeset/reference-store-integrity.md +++ /dev/null @@ -1,21 +0,0 @@ ---- -"@cloudhal/storage": minor -"@cloudhal/core-ts": minor -"@cloudhal/api": patch -"@cloudhal/mcp-server": patch ---- - -Reference fields get their index and integrity rules (RFC-0045 §2, rollout step 2a, #114). Both new field types stay refused on every write path in production, so no reference value can exist yet; the store and the shared suites run them through `SiteGraphStoreOptions.fieldTypes` and `CopySiteOptions.fieldTypes`. - -- **Storage.** Migration `0033_entry_refs` adds `entry_refs`, one row per stored reference value, removed with its site. -- **Store.** Entry writes keep the rows in their own batch and check their targets at batch time (`unknown_entry`, `reference_target_moved`). Deletes, moves and group changes are refused while a published entry shows a reference to the group's last usable member (`entry_referenced`, `reference_target_moved`, `field_operation_running`). Imports rebuild the rows beside a written node set. Field operations naming a reference or repeater field answer `field_operation_unsupported`. Definition changes that would strand values are refused (`field_key_in_use`, removed target collections or sub-fields, `multiple`). -- **API and MCP.** The new refusals answer 409 or 422, with MCP hints. - -**Behaviour changes on existing sites** (RFC-0045 decision 3): - -- relinking a node that other nodes use as their translation group is refused (`translation_group_in_use`, 409); -- `resolveFields` and the store read an original's non-localized values only when the original's own group is its id: a node relinked into another group lends them to nobody (OQ 14). The list-values fingerprint format moves to 2, so every listed collection's `entry_list_values` rebuild once (`lists.backfill`); listings scan until they are ready; -- a change of `translation.group` alone gets the same source-group check as a source change, and a write joining a group checks that its node is still that group's original; -- imports store node bodies in canonical form (the hash is unchanged); -- deletes, moves and group changes of entries carry the collections anchor, and entry writes that change `fields` or `collection` carry the definitions anchor: a concurrent change of the collections' settings makes them answer 409, and a retry succeeds. The anchors compare the stored text read when the write is planned, so site rows stored with any key order work; -- field operations that would turn a field into a reference or repeater answer `field_operation_unsupported` (409) instead of `fields_unsupported`. diff --git a/packages/agent-runtime/CHANGELOG.md b/packages/agent-runtime/CHANGELOG.md index bdd9ef1c..509787cc 100644 --- a/packages/agent-runtime/CHANGELOG.md +++ b/packages/agent-runtime/CHANGELOG.md @@ -1,5 +1,14 @@ # @cloudhal/agent-runtime +## 0.8.0 + +### Patch Changes + +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/agent-runtime/package.json b/packages/agent-runtime/package.json index cf71f803..2b417c16 100644 --- a/packages/agent-runtime/package.json +++ b/packages/agent-runtime/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/agent-runtime", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal agent runtime: policy engine (actors, scopes, approvals), skill loader, audit log", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/analytics/CHANGELOG.md b/packages/analytics/CHANGELOG.md index c45628d4..cbf07b98 100644 --- a/packages/analytics/CHANGELOG.md +++ b/packages/analytics/CHANGELOG.md @@ -1,5 +1,14 @@ # @cloudhal/analytics +## 0.8.0 + +### Patch Changes + +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/analytics/package.json b/packages/analytics/package.json index d044774c..aec6ea39 100644 --- a/packages/analytics/package.json +++ b/packages/analytics/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/analytics", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal site analytics (RFC-0006): query model, classifiers, beacon handler, SQLite/D1 store, daily rollups and Workers Analytics Engine adapters. Worker-safe.", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/api/CHANGELOG.md b/packages/api/CHANGELOG.md index c1ea6f2d..2e039a9c 100644 --- a/packages/api/CHANGELOG.md +++ b/packages/api/CHANGELOG.md @@ -1,5 +1,67 @@ # @cloudhal/api +## 0.8.0 + +### Minor Changes + +- dc519c0: The consumers of reference fields (RFC-0045 §2, rollout step 2b, #114). Both new field types stay refused on every write path in production, so none of this is reachable before rollout step 7. The shared suites run it through `SiteGraphStoreOptions.fieldTypes`. + + - **Assets inside repeater items.** `fieldAssetRefs` walks items and records `fields..` with each use's item path. `fieldAssetIssues` checks sub-field types (a PDF in an image sub-field is refused) and reports at every item that uses the file. Skips match issue paths by prefix, in the store and in the MCP precheck alike, so top-level behaviour is unchanged. + - **Field-operation rewrites** write their entries' `entry_refs` rows. A rewrite that changes a reference value is guarded on its target, and every rewrite in a site with reference fields is guarded on the collection's definitions. + - **Releases** no longer treat reference values as dependencies, so a referenced entry is neither locked nor required live. + - **Language editions** (`forEdition`) keep only what the edition's own write accepts. A reference needs a member of its group in an allowed collection that meets the field's `where`. A single-target field keeps one id, and a multiple field keeps at most `maxItems`. An entry holds at most 100 references, and a repeater at most `maxItems` items. Values are read through a running rename's old key. Everything not carried, including repeater items left empty, is reported with its reason through `onDropped`. A re-save keeps the values the edition entry already holds, as its own write would. + - **CLI.** `cloudhal import --dry-run` warns about references that will show nothing, and about originals relinked into another group. + - **Cloudflare.** `siteFieldTypeSupport` reads the site Worker's `fields` feature. `FIELDS_FEATURE_VERSION` and `FIELDS_SUPPORTED` are exported from `@cloudhal/core-ts/fields`. Nothing passes them to a store before step 7. + - **API.** `GET /sites/:siteId/entries/pick` is the entry picker. Its search folds case and diacritics on both sides with `foldName`, Turkish İ and ı included, and reads at most 1,000 entries per request. When that runs out before 20 matches, it answers `truncated: true` with a `cursor` to continue from. `GET /sites/:siteId/entries/:entryId/references` lists an entry's referrers, each with the language versions that show it. Both need `content:read`. + +### Patch Changes + +- b6cf70f: The contract gains two field types for collections, `reference` and `repeater` (RFC-0045 §1, rollout step 1, #114). Every write path still refuses them, so existing sites behave exactly as before. + + - **Contract.** `FieldDefinition` gains `ReferenceField` and `RepeaterField`. A new `SubFieldDefinition` union holds a repeater's sub-fields: scalar values only, so a repeater cannot contain a repeater. `FieldMigration.fromType` gains both types, and `FieldMigration` gains an optional `sub`. There is no `schemaVersion` bump, and existing documents stay valid. + - **The gate.** Until rollout step 7 enables them, a reference or repeater definition, or a migration marker that names one, is refused with `fields_unsupported`: API status 409, with an MCP hint. The refusal covers: + - site creates and updates, so Studio, MCP and the API; + - field operations; + - every bundle `importSite` takes: import, pull, push, `cloudhal import --replace` and `--revert`, snapshot restores and edition copies. + + `checkBundle` gained `assertFieldTypes`. It checks the working site row, and `prepareImport` checks every snapshot site body the import writes once it has been verified (bodies the target already holds are its own), and refuses the types when no capability is given. A push answers `409 fields_unsupported` with its issues, not `400 bad_request`. + - **Pure core** (`@cloudhal/core-ts/fields`), with no effect on stored data yet: + - the definition rules: `reference_target_unknown`, `where`, `itemLabel`, and caps on sub-fields and leaves; + - value checks for both types, the per-item `requiredToPublish`, and `too_many_references`; + - `resolveFields` skips types it does not know; + - `fieldsJsonSchema(…, { strict: true })` and `strictSchemaCost`; + - `pickMember`, `referenceIssues`, and `FIELD_QUERY_OPS` and structured-data entries that make neither type listable or mappable. + + `FIELD_TYPES` keeps the nine enabled types (`EnabledFieldType`). `ALL_FIELD_TYPES` lists all eleven. + - **MCP.** `update_collection`'s input now builds its `$defs` with `defsClosure` and offers only the enabled types. A test checks that every `$ref` in every tool's input and output schema resolves. Before this change, `pnpm gen` alone would have left the input pointing at `$defs` it did not carry. + - **Fix, existing sites:** block props and typed-field objects no longer accept keys named after `Object.prototype` members (`constructor`, `toString`, `__proto__`, …) as known props. The props interpreter (`validateProps`) now checks and reads own keys only. Such keys are refused as unknown, and a prop the value leaves out is absent, not the prototype's function. `toLocaleString`, `isPrototypeOf` and `propertyIsEnumerable` join the reserved field keys, beside `toString`, `valueOf` and `hasOwnProperty`. +- d107895: Reference fields get their index and integrity rules (RFC-0045 §2, rollout step 2a, #114). Both new field types stay refused on every write path in production, so no reference value can exist yet; the store and the shared suites run them through `SiteGraphStoreOptions.fieldTypes` and `CopySiteOptions.fieldTypes`. + + - **Storage.** Migration `0033_entry_refs` adds `entry_refs`, one row per stored reference value, removed with its site. + - **Store.** Entry writes keep the rows in their own batch and check their targets at batch time (`unknown_entry`, `reference_target_moved`). Deletes, moves and group changes are refused while a published entry shows a reference to the group's last usable member (`entry_referenced`, `reference_target_moved`, `field_operation_running`). Imports rebuild the rows beside a written node set. Field operations naming a reference or repeater field answer `field_operation_unsupported`. Definition changes that would strand values are refused (`field_key_in_use`, removed target collections or sub-fields, `multiple`). + - **API and MCP.** The new refusals answer 409 or 422, with MCP hints. + + **Behaviour changes on existing sites** (RFC-0045 decision 3): + + - relinking a node that other nodes use as their translation group is refused (`translation_group_in_use`, 409); + - `resolveFields` and the store read an original's non-localized values only when the original's own group is its id: a node relinked into another group lends them to nobody (OQ 14). The list-values fingerprint format moves to 2, so every listed collection's `entry_list_values` rebuild once (`lists.backfill`); listings scan until they are ready; + - a change of `translation.group` alone gets the same source-group check as a source change, and a write joining a group checks that its node is still that group's original; + - imports store node bodies in canonical form (the hash is unchanged); + - deletes, moves and group changes of entries carry the collections anchor, and entry writes that change `fields` or `collection` carry the definitions anchor: a concurrent change of the collections' settings makes them answer 409, and a retry succeeds. The anchors compare the stored text read when the write is planned, so site rows stored with any key order work; + - field operations that would turn a field into a reference or repeater answer `field_operation_unsupported` (409) instead of `fields_unsupported`. +- Updated dependencies [dc519c0] +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-ts@0.8.0 + - @cloudhal/mcp-server@0.8.0 + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + - @cloudhal/astro-renderer@0.8.0 + - @cloudhal/comments@0.8.0 + - @cloudhal/agent-runtime@0.8.0 + - @cloudhal/analytics@0.8.0 + - @cloudhal/schedules@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/api/package.json b/packages/api/package.json index 8fb7c4ff..e322db80 100644 --- a/packages/api/package.json +++ b/packages/api/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/api", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal HTTP API (Hono): sites, pages, entries, snapshots, auth — runs on Node and Cloudflare Workers", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/astro-renderer/CHANGELOG.md b/packages/astro-renderer/CHANGELOG.md index fc94ba5c..cf6b1356 100644 --- a/packages/astro-renderer/CHANGELOG.md +++ b/packages/astro-renderer/CHANGELOG.md @@ -1,5 +1,18 @@ # @cloudhal/astro-renderer +## 0.8.0 + +### Patch Changes + +- Updated dependencies [dc519c0] +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-ts@0.8.0 + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + - @cloudhal/comments@0.8.0 + - @cloudhal/analytics@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/astro-renderer/package.json b/packages/astro-renderer/package.json index 11cb6c65..52cf9942 100644 --- a/packages/astro-renderer/package.json +++ b/packages/astro-renderer/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/astro-renderer", - "version": "0.7.3", + "version": "0.8.0", "description": "Render a Cloudhal Site Graph with Astro: data sources (live/snapshot), section components and the cloudhal() integration", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/cli/CHANGELOG.md b/packages/cli/CHANGELOG.md index 65986b0f..6a5fe237 100644 --- a/packages/cli/CHANGELOG.md +++ b/packages/cli/CHANGELOG.md @@ -1,5 +1,33 @@ # @cloudhal/cli +## 0.8.0 + +### Patch Changes + +- dc519c0: The consumers of reference fields (RFC-0045 §2, rollout step 2b, #114). Both new field types stay refused on every write path in production, so none of this is reachable before rollout step 7. The shared suites run it through `SiteGraphStoreOptions.fieldTypes`. + + - **Assets inside repeater items.** `fieldAssetRefs` walks items and records `fields..` with each use's item path. `fieldAssetIssues` checks sub-field types (a PDF in an image sub-field is refused) and reports at every item that uses the file. Skips match issue paths by prefix, in the store and in the MCP precheck alike, so top-level behaviour is unchanged. + - **Field-operation rewrites** write their entries' `entry_refs` rows. A rewrite that changes a reference value is guarded on its target, and every rewrite in a site with reference fields is guarded on the collection's definitions. + - **Releases** no longer treat reference values as dependencies, so a referenced entry is neither locked nor required live. + - **Language editions** (`forEdition`) keep only what the edition's own write accepts. A reference needs a member of its group in an allowed collection that meets the field's `where`. A single-target field keeps one id, and a multiple field keeps at most `maxItems`. An entry holds at most 100 references, and a repeater at most `maxItems` items. Values are read through a running rename's old key. Everything not carried, including repeater items left empty, is reported with its reason through `onDropped`. A re-save keeps the values the edition entry already holds, as its own write would. + - **CLI.** `cloudhal import --dry-run` warns about references that will show nothing, and about originals relinked into another group. + - **Cloudflare.** `siteFieldTypeSupport` reads the site Worker's `fields` feature. `FIELDS_FEATURE_VERSION` and `FIELDS_SUPPORTED` are exported from `@cloudhal/core-ts/fields`. Nothing passes them to a store before step 7. + - **API.** `GET /sites/:siteId/entries/pick` is the entry picker. Its search folds case and diacritics on both sides with `foldName`, Turkish İ and ı included, and reads at most 1,000 entries per request. When that runs out before 20 matches, it answers `truncated: true` with a `cursor` to continue from. `GET /sites/:siteId/entries/:entryId/references` lists an entry's referrers, each with the language versions that show it. Both need `content:read`. +- Updated dependencies [dc519c0] +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-ts@0.8.0 + - @cloudhal/api@0.8.0 + - @cloudhal/cloudflare@0.8.0 + - @cloudhal/mcp-server@0.8.0 + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + - @cloudhal/astro-renderer@0.8.0 + - @cloudhal/comments@0.8.0 + - @cloudhal/agent-runtime@0.8.0 + - @cloudhal/analytics@0.8.0 + - @cloudhal/schedules@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/cli/package.json b/packages/cli/package.json index a8c22508..abf7a7ba 100644 --- a/packages/cli/package.json +++ b/packages/cli/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/cli", - "version": "0.7.3", + "version": "0.8.0", "description": "cloudhal — create, run and build Cloudhal sites locally", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/cloudflare/CHANGELOG.md b/packages/cloudflare/CHANGELOG.md index ae4abeb1..6a34f4a7 100644 --- a/packages/cloudflare/CHANGELOG.md +++ b/packages/cloudflare/CHANGELOG.md @@ -1,5 +1,30 @@ # @cloudhal/cloudflare +## 0.8.0 + +### Patch Changes + +- dc519c0: The consumers of reference fields (RFC-0045 §2, rollout step 2b, #114). Both new field types stay refused on every write path in production, so none of this is reachable before rollout step 7. The shared suites run it through `SiteGraphStoreOptions.fieldTypes`. + + - **Assets inside repeater items.** `fieldAssetRefs` walks items and records `fields..` with each use's item path. `fieldAssetIssues` checks sub-field types (a PDF in an image sub-field is refused) and reports at every item that uses the file. Skips match issue paths by prefix, in the store and in the MCP precheck alike, so top-level behaviour is unchanged. + - **Field-operation rewrites** write their entries' `entry_refs` rows. A rewrite that changes a reference value is guarded on its target, and every rewrite in a site with reference fields is guarded on the collection's definitions. + - **Releases** no longer treat reference values as dependencies, so a referenced entry is neither locked nor required live. + - **Language editions** (`forEdition`) keep only what the edition's own write accepts. A reference needs a member of its group in an allowed collection that meets the field's `where`. A single-target field keeps one id, and a multiple field keeps at most `maxItems`. An entry holds at most 100 references, and a repeater at most `maxItems` items. Values are read through a running rename's old key. Everything not carried, including repeater items left empty, is reported with its reason through `onDropped`. A re-save keeps the values the edition entry already holds, as its own write would. + - **CLI.** `cloudhal import --dry-run` warns about references that will show nothing, and about originals relinked into another group. + - **Cloudflare.** `siteFieldTypeSupport` reads the site Worker's `fields` feature. `FIELDS_FEATURE_VERSION` and `FIELDS_SUPPORTED` are exported from `@cloudhal/core-ts/fields`. Nothing passes them to a store before step 7. + - **API.** `GET /sites/:siteId/entries/pick` is the entry picker. Its search folds case and diacritics on both sides with `foldName`, Turkish İ and ı included, and reads at most 1,000 entries per request. When that runs out before 20 matches, it answers `truncated: true` with a `cursor` to continue from. `GET /sites/:siteId/entries/:entryId/references` lists an entry's referrers, each with the language versions that show it. Both need `content:read`. +- Updated dependencies [dc519c0] +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-ts@0.8.0 + - @cloudhal/api@0.8.0 + - @cloudhal/mcp-server@0.8.0 + - @cloudhal/storage@0.8.0 + - @cloudhal/comments@0.8.0 + - @cloudhal/agent-runtime@0.8.0 + - @cloudhal/analytics@0.8.0 + - @cloudhal/schedules@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/cloudflare/package.json b/packages/cloudflare/package.json index 985291b7..bc7342ab 100644 --- a/packages/cloudflare/package.json +++ b/packages/cloudflare/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/cloudflare", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal on Cloudflare: the admin Worker (API, auth, MCP, Studio) over D1 + R2", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/comments/CHANGELOG.md b/packages/comments/CHANGELOG.md index aaf29b8f..e2f326ca 100644 --- a/packages/comments/CHANGELOG.md +++ b/packages/comments/CHANGELOG.md @@ -1,5 +1,16 @@ # @cloudhal/comments +## 0.8.0 + +### Patch Changes + +- Updated dependencies [dc519c0] +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-ts@0.8.0 + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/comments/package.json b/packages/comments/package.json index 6b5f9422..fd3aa4a2 100644 --- a/packages/comments/package.json +++ b/packages/comments/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/comments", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal reader comments (RFC-0007): settings and thread state, text normalising and content rules, linkify, first-party proof of work, the submission pipeline, purge planner, retention plan and the SQLite/D1 store. Worker-safe.", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/core-contracts/CHANGELOG.md b/packages/core-contracts/CHANGELOG.md index a2024b61..5239fec0 100644 --- a/packages/core-contracts/CHANGELOG.md +++ b/packages/core-contracts/CHANGELOG.md @@ -1,5 +1,29 @@ # @cloudhal/core-contracts +## 0.8.0 + +### Minor Changes + +- b6cf70f: The contract gains two field types for collections, `reference` and `repeater` (RFC-0045 §1, rollout step 1, #114). Every write path still refuses them, so existing sites behave exactly as before. + + - **Contract.** `FieldDefinition` gains `ReferenceField` and `RepeaterField`. A new `SubFieldDefinition` union holds a repeater's sub-fields: scalar values only, so a repeater cannot contain a repeater. `FieldMigration.fromType` gains both types, and `FieldMigration` gains an optional `sub`. There is no `schemaVersion` bump, and existing documents stay valid. + - **The gate.** Until rollout step 7 enables them, a reference or repeater definition, or a migration marker that names one, is refused with `fields_unsupported`: API status 409, with an MCP hint. The refusal covers: + - site creates and updates, so Studio, MCP and the API; + - field operations; + - every bundle `importSite` takes: import, pull, push, `cloudhal import --replace` and `--revert`, snapshot restores and edition copies. + + `checkBundle` gained `assertFieldTypes`. It checks the working site row, and `prepareImport` checks every snapshot site body the import writes once it has been verified (bodies the target already holds are its own), and refuses the types when no capability is given. A push answers `409 fields_unsupported` with its issues, not `400 bad_request`. + - **Pure core** (`@cloudhal/core-ts/fields`), with no effect on stored data yet: + - the definition rules: `reference_target_unknown`, `where`, `itemLabel`, and caps on sub-fields and leaves; + - value checks for both types, the per-item `requiredToPublish`, and `too_many_references`; + - `resolveFields` skips types it does not know; + - `fieldsJsonSchema(…, { strict: true })` and `strictSchemaCost`; + - `pickMember`, `referenceIssues`, and `FIELD_QUERY_OPS` and structured-data entries that make neither type listable or mappable. + + `FIELD_TYPES` keeps the nine enabled types (`EnabledFieldType`). `ALL_FIELD_TYPES` lists all eleven. + - **MCP.** `update_collection`'s input now builds its `$defs` with `defsClosure` and offers only the enabled types. A test checks that every `$ref` in every tool's input and output schema resolves. Before this change, `pnpm gen` alone would have left the input pointing at `$defs` it did not carry. + - **Fix, existing sites:** block props and typed-field objects no longer accept keys named after `Object.prototype` members (`constructor`, `toString`, `__proto__`, …) as known props. The props interpreter (`validateProps`) now checks and reads own keys only. Such keys are refused as unknown, and a prop the value leaves out is absent, not the prototype's function. `toLocaleString`, `isPrototypeOf` and `propertyIsEnumerable` join the reserved field keys, beside `toString`, `valueOf` and `hasOwnProperty`. + ## 0.7.3 No changes in this release. diff --git a/packages/core-contracts/package.json b/packages/core-contracts/package.json index 8c355d49..d793bfa1 100644 --- a/packages/core-contracts/package.json +++ b/packages/core-contracts/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/core-contracts", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal domain contracts: JSON Schema source of truth plus generated TypeScript types", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/core-ts/CHANGELOG.md b/packages/core-ts/CHANGELOG.md index 5e134471..3b465ee9 100644 --- a/packages/core-ts/CHANGELOG.md +++ b/packages/core-ts/CHANGELOG.md @@ -1,5 +1,60 @@ # @cloudhal/core-ts +## 0.8.0 + +### Minor Changes + +- dc519c0: The consumers of reference fields (RFC-0045 §2, rollout step 2b, #114). Both new field types stay refused on every write path in production, so none of this is reachable before rollout step 7. The shared suites run it through `SiteGraphStoreOptions.fieldTypes`. + + - **Assets inside repeater items.** `fieldAssetRefs` walks items and records `fields..` with each use's item path. `fieldAssetIssues` checks sub-field types (a PDF in an image sub-field is refused) and reports at every item that uses the file. Skips match issue paths by prefix, in the store and in the MCP precheck alike, so top-level behaviour is unchanged. + - **Field-operation rewrites** write their entries' `entry_refs` rows. A rewrite that changes a reference value is guarded on its target, and every rewrite in a site with reference fields is guarded on the collection's definitions. + - **Releases** no longer treat reference values as dependencies, so a referenced entry is neither locked nor required live. + - **Language editions** (`forEdition`) keep only what the edition's own write accepts. A reference needs a member of its group in an allowed collection that meets the field's `where`. A single-target field keeps one id, and a multiple field keeps at most `maxItems`. An entry holds at most 100 references, and a repeater at most `maxItems` items. Values are read through a running rename's old key. Everything not carried, including repeater items left empty, is reported with its reason through `onDropped`. A re-save keeps the values the edition entry already holds, as its own write would. + - **CLI.** `cloudhal import --dry-run` warns about references that will show nothing, and about originals relinked into another group. + - **Cloudflare.** `siteFieldTypeSupport` reads the site Worker's `fields` feature. `FIELDS_FEATURE_VERSION` and `FIELDS_SUPPORTED` are exported from `@cloudhal/core-ts/fields`. Nothing passes them to a store before step 7. + - **API.** `GET /sites/:siteId/entries/pick` is the entry picker. Its search folds case and diacritics on both sides with `foldName`, Turkish İ and ı included, and reads at most 1,000 entries per request. When that runs out before 20 matches, it answers `truncated: true` with a `cursor` to continue from. `GET /sites/:siteId/entries/:entryId/references` lists an entry's referrers, each with the language versions that show it. Both need `content:read`. +- d107895: Reference fields get their index and integrity rules (RFC-0045 §2, rollout step 2a, #114). Both new field types stay refused on every write path in production, so no reference value can exist yet; the store and the shared suites run them through `SiteGraphStoreOptions.fieldTypes` and `CopySiteOptions.fieldTypes`. + + - **Storage.** Migration `0033_entry_refs` adds `entry_refs`, one row per stored reference value, removed with its site. + - **Store.** Entry writes keep the rows in their own batch and check their targets at batch time (`unknown_entry`, `reference_target_moved`). Deletes, moves and group changes are refused while a published entry shows a reference to the group's last usable member (`entry_referenced`, `reference_target_moved`, `field_operation_running`). Imports rebuild the rows beside a written node set. Field operations naming a reference or repeater field answer `field_operation_unsupported`. Definition changes that would strand values are refused (`field_key_in_use`, removed target collections or sub-fields, `multiple`). + - **API and MCP.** The new refusals answer 409 or 422, with MCP hints. + + **Behaviour changes on existing sites** (RFC-0045 decision 3): + + - relinking a node that other nodes use as their translation group is refused (`translation_group_in_use`, 409); + - `resolveFields` and the store read an original's non-localized values only when the original's own group is its id: a node relinked into another group lends them to nobody (OQ 14). The list-values fingerprint format moves to 2, so every listed collection's `entry_list_values` rebuild once (`lists.backfill`); listings scan until they are ready; + - a change of `translation.group` alone gets the same source-group check as a source change, and a write joining a group checks that its node is still that group's original; + - imports store node bodies in canonical form (the hash is unchanged); + - deletes, moves and group changes of entries carry the collections anchor, and entry writes that change `fields` or `collection` carry the definitions anchor: a concurrent change of the collections' settings makes them answer 409, and a retry succeeds. The anchors compare the stored text read when the write is planned, so site rows stored with any key order work; + - field operations that would turn a field into a reference or repeater answer `field_operation_unsupported` (409) instead of `fields_unsupported`. + +### Patch Changes + +- b6cf70f: The contract gains two field types for collections, `reference` and `repeater` (RFC-0045 §1, rollout step 1, #114). Every write path still refuses them, so existing sites behave exactly as before. + + - **Contract.** `FieldDefinition` gains `ReferenceField` and `RepeaterField`. A new `SubFieldDefinition` union holds a repeater's sub-fields: scalar values only, so a repeater cannot contain a repeater. `FieldMigration.fromType` gains both types, and `FieldMigration` gains an optional `sub`. There is no `schemaVersion` bump, and existing documents stay valid. + - **The gate.** Until rollout step 7 enables them, a reference or repeater definition, or a migration marker that names one, is refused with `fields_unsupported`: API status 409, with an MCP hint. The refusal covers: + - site creates and updates, so Studio, MCP and the API; + - field operations; + - every bundle `importSite` takes: import, pull, push, `cloudhal import --replace` and `--revert`, snapshot restores and edition copies. + + `checkBundle` gained `assertFieldTypes`. It checks the working site row, and `prepareImport` checks every snapshot site body the import writes once it has been verified (bodies the target already holds are its own), and refuses the types when no capability is given. A push answers `409 fields_unsupported` with its issues, not `400 bad_request`. + - **Pure core** (`@cloudhal/core-ts/fields`), with no effect on stored data yet: + - the definition rules: `reference_target_unknown`, `where`, `itemLabel`, and caps on sub-fields and leaves; + - value checks for both types, the per-item `requiredToPublish`, and `too_many_references`; + - `resolveFields` skips types it does not know; + - `fieldsJsonSchema(…, { strict: true })` and `strictSchemaCost`; + - `pickMember`, `referenceIssues`, and `FIELD_QUERY_OPS` and structured-data entries that make neither type listable or mappable. + + `FIELD_TYPES` keeps the nine enabled types (`EnabledFieldType`). `ALL_FIELD_TYPES` lists all eleven. + - **MCP.** `update_collection`'s input now builds its `$defs` with `defsClosure` and offers only the enabled types. A test checks that every `$ref` in every tool's input and output schema resolves. Before this change, `pnpm gen` alone would have left the input pointing at `$defs` it did not carry. + - **Fix, existing sites:** block props and typed-field objects no longer accept keys named after `Object.prototype` members (`constructor`, `toString`, `__proto__`, …) as known props. The props interpreter (`validateProps`) now checks and reads own keys only. Such keys are refused as unknown, and a prop the value leaves out is absent, not the prototype's function. `toLocaleString`, `isPrototypeOf` and `propertyIsEnumerable` join the reserved field keys, beside `toString`, `valueOf` and `hasOwnProperty`. +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + - @cloudhal/schedules@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/core-ts/package.json b/packages/core-ts/package.json index 2389a882..77653539 100644 --- a/packages/core-ts/package.json +++ b/packages/core-ts/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/core-ts", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal Site Graph core (TypeScript): load/save nodes with optimistic locking, snapshots, diff, publish and rollback; taxonomies, terms, redirects and menus", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/create-cloudhal/CHANGELOG.md b/packages/create-cloudhal/CHANGELOG.md index 47bfc3c4..6583ba14 100644 --- a/packages/create-cloudhal/CHANGELOG.md +++ b/packages/create-cloudhal/CHANGELOG.md @@ -1,5 +1,12 @@ # create-cloudhal +## 0.8.0 + +### Patch Changes + +- Updated dependencies [dc519c0] + - @cloudhal/cli@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/create-cloudhal/package.json b/packages/create-cloudhal/package.json index 8a005b27..a431b49f 100644 --- a/packages/create-cloudhal/package.json +++ b/packages/create-cloudhal/package.json @@ -1,6 +1,6 @@ { "name": "create-cloudhal", - "version": "0.7.3", + "version": "0.8.0", "description": "Create a Cloudhal site: npm create cloudhal@latest", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/mcp-server/CHANGELOG.md b/packages/mcp-server/CHANGELOG.md index 08ef7931..ee201eee 100644 --- a/packages/mcp-server/CHANGELOG.md +++ b/packages/mcp-server/CHANGELOG.md @@ -1,5 +1,63 @@ # @cloudhal/mcp-server +## 0.8.0 + +### Patch Changes + +- dc519c0: The consumers of reference fields (RFC-0045 §2, rollout step 2b, #114). Both new field types stay refused on every write path in production, so none of this is reachable before rollout step 7. The shared suites run it through `SiteGraphStoreOptions.fieldTypes`. + + - **Assets inside repeater items.** `fieldAssetRefs` walks items and records `fields..` with each use's item path. `fieldAssetIssues` checks sub-field types (a PDF in an image sub-field is refused) and reports at every item that uses the file. Skips match issue paths by prefix, in the store and in the MCP precheck alike, so top-level behaviour is unchanged. + - **Field-operation rewrites** write their entries' `entry_refs` rows. A rewrite that changes a reference value is guarded on its target, and every rewrite in a site with reference fields is guarded on the collection's definitions. + - **Releases** no longer treat reference values as dependencies, so a referenced entry is neither locked nor required live. + - **Language editions** (`forEdition`) keep only what the edition's own write accepts. A reference needs a member of its group in an allowed collection that meets the field's `where`. A single-target field keeps one id, and a multiple field keeps at most `maxItems`. An entry holds at most 100 references, and a repeater at most `maxItems` items. Values are read through a running rename's old key. Everything not carried, including repeater items left empty, is reported with its reason through `onDropped`. A re-save keeps the values the edition entry already holds, as its own write would. + - **CLI.** `cloudhal import --dry-run` warns about references that will show nothing, and about originals relinked into another group. + - **Cloudflare.** `siteFieldTypeSupport` reads the site Worker's `fields` feature. `FIELDS_FEATURE_VERSION` and `FIELDS_SUPPORTED` are exported from `@cloudhal/core-ts/fields`. Nothing passes them to a store before step 7. + - **API.** `GET /sites/:siteId/entries/pick` is the entry picker. Its search folds case and diacritics on both sides with `foldName`, Turkish İ and ı included, and reads at most 1,000 entries per request. When that runs out before 20 matches, it answers `truncated: true` with a `cursor` to continue from. `GET /sites/:siteId/entries/:entryId/references` lists an entry's referrers, each with the language versions that show it. Both need `content:read`. +- b6cf70f: The contract gains two field types for collections, `reference` and `repeater` (RFC-0045 §1, rollout step 1, #114). Every write path still refuses them, so existing sites behave exactly as before. + + - **Contract.** `FieldDefinition` gains `ReferenceField` and `RepeaterField`. A new `SubFieldDefinition` union holds a repeater's sub-fields: scalar values only, so a repeater cannot contain a repeater. `FieldMigration.fromType` gains both types, and `FieldMigration` gains an optional `sub`. There is no `schemaVersion` bump, and existing documents stay valid. + - **The gate.** Until rollout step 7 enables them, a reference or repeater definition, or a migration marker that names one, is refused with `fields_unsupported`: API status 409, with an MCP hint. The refusal covers: + - site creates and updates, so Studio, MCP and the API; + - field operations; + - every bundle `importSite` takes: import, pull, push, `cloudhal import --replace` and `--revert`, snapshot restores and edition copies. + + `checkBundle` gained `assertFieldTypes`. It checks the working site row, and `prepareImport` checks every snapshot site body the import writes once it has been verified (bodies the target already holds are its own), and refuses the types when no capability is given. A push answers `409 fields_unsupported` with its issues, not `400 bad_request`. + - **Pure core** (`@cloudhal/core-ts/fields`), with no effect on stored data yet: + - the definition rules: `reference_target_unknown`, `where`, `itemLabel`, and caps on sub-fields and leaves; + - value checks for both types, the per-item `requiredToPublish`, and `too_many_references`; + - `resolveFields` skips types it does not know; + - `fieldsJsonSchema(…, { strict: true })` and `strictSchemaCost`; + - `pickMember`, `referenceIssues`, and `FIELD_QUERY_OPS` and structured-data entries that make neither type listable or mappable. + + `FIELD_TYPES` keeps the nine enabled types (`EnabledFieldType`). `ALL_FIELD_TYPES` lists all eleven. + - **MCP.** `update_collection`'s input now builds its `$defs` with `defsClosure` and offers only the enabled types. A test checks that every `$ref` in every tool's input and output schema resolves. Before this change, `pnpm gen` alone would have left the input pointing at `$defs` it did not carry. + - **Fix, existing sites:** block props and typed-field objects no longer accept keys named after `Object.prototype` members (`constructor`, `toString`, `__proto__`, …) as known props. The props interpreter (`validateProps`) now checks and reads own keys only. Such keys are refused as unknown, and a prop the value leaves out is absent, not the prototype's function. `toLocaleString`, `isPrototypeOf` and `propertyIsEnumerable` join the reserved field keys, beside `toString`, `valueOf` and `hasOwnProperty`. +- d107895: Reference fields get their index and integrity rules (RFC-0045 §2, rollout step 2a, #114). Both new field types stay refused on every write path in production, so no reference value can exist yet; the store and the shared suites run them through `SiteGraphStoreOptions.fieldTypes` and `CopySiteOptions.fieldTypes`. + + - **Storage.** Migration `0033_entry_refs` adds `entry_refs`, one row per stored reference value, removed with its site. + - **Store.** Entry writes keep the rows in their own batch and check their targets at batch time (`unknown_entry`, `reference_target_moved`). Deletes, moves and group changes are refused while a published entry shows a reference to the group's last usable member (`entry_referenced`, `reference_target_moved`, `field_operation_running`). Imports rebuild the rows beside a written node set. Field operations naming a reference or repeater field answer `field_operation_unsupported`. Definition changes that would strand values are refused (`field_key_in_use`, removed target collections or sub-fields, `multiple`). + - **API and MCP.** The new refusals answer 409 or 422, with MCP hints. + + **Behaviour changes on existing sites** (RFC-0045 decision 3): + + - relinking a node that other nodes use as their translation group is refused (`translation_group_in_use`, 409); + - `resolveFields` and the store read an original's non-localized values only when the original's own group is its id: a node relinked into another group lends them to nobody (OQ 14). The list-values fingerprint format moves to 2, so every listed collection's `entry_list_values` rebuild once (`lists.backfill`); listings scan until they are ready; + - a change of `translation.group` alone gets the same source-group check as a source change, and a write joining a group checks that its node is still that group's original; + - imports store node bodies in canonical form (the hash is unchanged); + - deletes, moves and group changes of entries carry the collections anchor, and entry writes that change `fields` or `collection` carry the definitions anchor: a concurrent change of the collections' settings makes them answer 409, and a retry succeeds. The anchors compare the stored text read when the write is planned, so site rows stored with any key order work; + - field operations that would turn a field into a reference or repeater answer `field_operation_unsupported` (409) instead of `fields_unsupported`. +- Updated dependencies [dc519c0] +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-ts@0.8.0 + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + - @cloudhal/astro-renderer@0.8.0 + - @cloudhal/comments@0.8.0 + - @cloudhal/agent-runtime@0.8.0 + - @cloudhal/analytics@0.8.0 + - @cloudhal/schedules@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json index 961a3f79..788472cf 100644 --- a/packages/mcp-server/package.json +++ b/packages/mcp-server/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/mcp-server", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal MCP server: semantic site tools (pages, articles, snapshots, preview, publish) governed by the policy engine", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/schedules/CHANGELOG.md b/packages/schedules/CHANGELOG.md index e94a4255..1d9ccd42 100644 --- a/packages/schedules/CHANGELOG.md +++ b/packages/schedules/CHANGELOG.md @@ -1,5 +1,14 @@ # @cloudhal/schedules +## 0.8.0 + +### Patch Changes + +- Updated dependencies [b6cf70f] +- Updated dependencies [d107895] + - @cloudhal/core-contracts@0.8.0 + - @cloudhal/storage@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/schedules/package.json b/packages/schedules/package.json index 2d86c15e..850d6134 100644 --- a/packages/schedules/package.json +++ b/packages/schedules/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/schedules", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal schedules (RFC-0008): the time model, the RRULE subset and its sentences, releases (pin, closure, rl1: hash, compose, conflicts, state machine), automation and run state, taint and budget accounting, the Scheduler and runDue, and the SQLite/D1 store. Worker-safe.", "license": "Apache-2.0", "homepage": "https://cloudhal.dev", diff --git a/packages/storage/CHANGELOG.md b/packages/storage/CHANGELOG.md index e72037e6..687e935c 100644 --- a/packages/storage/CHANGELOG.md +++ b/packages/storage/CHANGELOG.md @@ -1,5 +1,29 @@ # @cloudhal/storage +## 0.8.0 + +### Minor Changes + +- d107895: Reference fields get their index and integrity rules (RFC-0045 §2, rollout step 2a, #114). Both new field types stay refused on every write path in production, so no reference value can exist yet; the store and the shared suites run them through `SiteGraphStoreOptions.fieldTypes` and `CopySiteOptions.fieldTypes`. + + - **Storage.** Migration `0033_entry_refs` adds `entry_refs`, one row per stored reference value, removed with its site. + - **Store.** Entry writes keep the rows in their own batch and check their targets at batch time (`unknown_entry`, `reference_target_moved`). Deletes, moves and group changes are refused while a published entry shows a reference to the group's last usable member (`entry_referenced`, `reference_target_moved`, `field_operation_running`). Imports rebuild the rows beside a written node set. Field operations naming a reference or repeater field answer `field_operation_unsupported`. Definition changes that would strand values are refused (`field_key_in_use`, removed target collections or sub-fields, `multiple`). + - **API and MCP.** The new refusals answer 409 or 422, with MCP hints. + + **Behaviour changes on existing sites** (RFC-0045 decision 3): + + - relinking a node that other nodes use as their translation group is refused (`translation_group_in_use`, 409); + - `resolveFields` and the store read an original's non-localized values only when the original's own group is its id: a node relinked into another group lends them to nobody (OQ 14). The list-values fingerprint format moves to 2, so every listed collection's `entry_list_values` rebuild once (`lists.backfill`); listings scan until they are ready; + - a change of `translation.group` alone gets the same source-group check as a source change, and a write joining a group checks that its node is still that group's original; + - imports store node bodies in canonical form (the hash is unchanged); + - deletes, moves and group changes of entries carry the collections anchor, and entry writes that change `fields` or `collection` carry the definitions anchor: a concurrent change of the collections' settings makes them answer 409, and a retry succeeds. The anchors compare the stored text read when the write is planned, so site rows stored with any key order work; + - field operations that would turn a field into a reference or repeater answer `field_operation_unsupported` (409) instead of `fields_unsupported`. + +### Patch Changes + +- Updated dependencies [b6cf70f] + - @cloudhal/core-contracts@0.8.0 + ## 0.7.3 ### Patch Changes diff --git a/packages/storage/package.json b/packages/storage/package.json index c2173435..bce58e4e 100644 --- a/packages/storage/package.json +++ b/packages/storage/package.json @@ -1,6 +1,6 @@ { "name": "@cloudhal/storage", - "version": "0.7.3", + "version": "0.8.0", "description": "Cloudhal storage interfaces (SQL driver, blob store) with Cloudflare D1/R2/Durable Object SQLite and local SQLite/filesystem adapters", "license": "Apache-2.0", "homepage": "https://cloudhal.dev",