@slats/claude-assets-sync 0.1.4 → 0.2.0

package/docs/claude/skills/claude-sync-applier/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: claude-sync-applier
+description: "Wire the claude-sync CLI onto a consumer package in this monorepo. Copies verbatim bin/claude-sync.mjs and scripts/build-hashes.mjs stubs, patches package.json, updates CLAUDE.md, runs E2E smoke tests, and verifies bundle isolation. Idempotent — asks before clobbering."
+user-invocable: true
+disable-model-invocation: true
+argument-hint: <target-package-path>
+---
+
+# claude-sync-applier
+
+Replicate the `claude-sync` bin setup on a target consumer package. The engine
+is `@slats/claude-assets-sync`; the reference consumer is `packages/canard/schema-form`.
+
+The bin stub reads its own `package.json` via `import.meta.url` and hands the
+engine `{ packageRoot, packageName, packageVersion, assetPath }`. Each invocation
+targets exactly one consumer — it does not discover other packages.
+
+**Outcome**
+
+```bash
+npx <PACKAGE_NAME> claude-sync --scope=user|project [--dry-run] [--force] [--root=<cwd>]
+```
+
+## Role
+
+You are a monorepo wiring specialist. Execute the 10 steps below as a single,
+idempotent procedure. On any conflicting existing value — ask the user before
+overwriting. Never clobber silently.
+
+## Knowledge Resources
+
+Consult these files as needed during execution. Do NOT preload everything;
+load on demand.
+
+- `knowledge/reference-files.md` — source stubs (`bin/claude-sync.mjs`, `scripts/build-hashes.mjs`) with expected contents and rationale
+- `knowledge/package-json-patches.md` — every required `package.json` edit, with guard conditions
+- `knowledge/claude-md-template.md` — the `## Claude Docs Injector` section to inject into the target `CLAUDE.md`
+- `knowledge/dependency-cruiser.md` — optional Step 4: three forbidden rules + config shape for static isolation
+- `knowledge/smoke-tests.md` — E2E 6-path matrix with expected exit codes and why
+- `knowledge/gotchas.md` — invariants, isolation guardrails, pitfalls
+
+## Inputs
+
+Resolve these before starting. If any is missing, stop and ask.
+
+| Variable          | Source                                                                                               |
+|-------------------|------------------------------------------------------------------------------------------------------|
+| `TARGET_PATH`     | Skill argument (e.g. `packages/lerx/promise-modal`). If absent, ask the user.                        |
+| `PACKAGE_NAME`    | `name` field of `${TARGET_PATH}/package.json`.                                                       |
+| `SHORTCUT`        | Root `package.json` `scripts` entry whose value equals `yarn workspace ${PACKAGE_NAME}`; else unset. |
+
+`SHORTCUT` is a convenience only. When unset, fall back to full workspace
+syntax: `yarn workspace ${PACKAGE_NAME} <subcommand>`.
+
+## Pre-Flight
+
+Stop and report on any failure. Do not attempt to fix silently.
+
+- [ ] `${TARGET_PATH}/docs/claude/skills/<name>/SKILL.md` and `knowledge/*.md` exist — the docs to be injected.
+- [ ] `${TARGET_PATH}/package.json` has `"type": "module"` and `"sideEffects": false`.
+- [ ] Build pipeline uses `rollup -c && yarn build:types` where `build:types` runs `node ../../aileron/script/build/buildTypes.mjs`.
+- [ ] `git status` in `${TARGET_PATH}` is clean. Unrelated changes present → confirm with user before proceeding.
+
+## Steps
+
+Execute in order. Each step is idempotent; on conflict, ask rather than overwrite.
+
+### Step 1 — Create `${TARGET_PATH}/bin/claude-sync.mjs`
+
+Copy verbatim from the reference consumer. See `knowledge/reference-files.md`
+for the expected content and the source path. `chmod +x` the result.
+
+### Step 2 — Create `${TARGET_PATH}/scripts/build-hashes.mjs`
+
+Copy verbatim. See `knowledge/reference-files.md`.
+
+### Step 3 — Patch `${TARGET_PATH}/package.json`
+
+See `knowledge/package-json-patches.md` for the complete patch list:
+
+- `bin` entry
+- `files` append
+- `scripts.build` append (guarded)
+- `scripts.build:hashes`
+- `scripts.prepublishOnly`
+- `dependencies."@slats/claude-assets-sync"` (NOT devDependencies)
+- `claude.assetPath` default
+
+Do NOT add `./bin/*` to `exports` — ever.
+
+### Step 4 — (Optional) dependency-cruiser isolation gate
+
+Skip unless `${TARGET_PATH}/.dependency-cruiser.cjs` already exists or the user
+explicitly asks. Legacy `.dependency-cruiser.js` → out of scope; flag to user.
+
+When applicable, see `knowledge/dependency-cruiser.md` for the three forbidden
+rules, `no-orphans` adjustment, `includeOnly` expansion, and `depcheck` script.
+
+### Step 5 — Patch `${TARGET_PATH}/CLAUDE.md`
+
+If `CLAUDE.md` exists, append the `## Claude Docs Injector` section from
+`knowledge/claude-md-template.md`, substituting `@canard/schema-form` →
+`${PACKAGE_NAME}`. Keep the Isolation Guardrails subsection. Skip if
+`CLAUDE.md` does not exist.
+
+### Step 6 — Install and build
+
+```bash
+yarn install
+yarn ${SHORTCUT:-workspace ${PACKAGE_NAME}} build
+```
+
+Expected: `rollup` → `buildTypes` → `build:hashes` succeed, and
+`${TARGET_PATH}/dist/claude-hashes.json` is written.
+
+### Step 7 — E2E smoke tests (6 paths)
+
+Run from `/tmp/...`, never from the monorepo root or `${TARGET_PATH}/` —
+`--scope=project` walks cwd upward looking for an existing `.claude`, and would
+mutate the real repo's. See `knowledge/smoke-tests.md` for the full 6-path
+matrix, expected exit codes, and rationale.
+
+Split into two bash calls (paths 1–3, then 4–6). cwd resets between calls; the
+`[ -d ... ] && find -delete` prefix keeps it idempotent. Never use `rm -rf` or
+unquoted `*` globs.
+
+### Step 8 — Bundle isolation grep (must be empty)
+
+```bash
+grep -rE "@slats/claude-assets-sync|docs/claude|claude-sync" \
+  ${TARGET_PATH}/dist/index.mjs ${TARGET_PATH}/dist/index.cjs
+```
+
+Pass = exit code 1 (no matches). Any match → stop; CLI has leaked into the
+library bundle. See `knowledge/gotchas.md` for the three-layer isolation model.
+
+### Step 9 — depcheck (only if Step 4 ran)
+
+```bash
+yarn ${SHORTCUT:-workspace ${PACKAGE_NAME}} depcheck
+```
+
+Zero errors. Pre-existing `no-orphans` warnings are acceptable.
+
+### Step 10 — Report
+
+Summarize:
+
+- Files written vs. skipped (with reason for each skip)
+- Manifest file count from `dist/claude-hashes.json`
+- Smoke-test exit codes (all 6)
+- Grep result (expected: no matches)
+- depcheck result (or "static isolation not enforced" if Step 4 skipped)
+- Recommendation: commit this change on its own, separate from other work
+
+## Report Template
+
+```markdown
+## apply-claude-sync — ${PACKAGE_NAME}
+
+**Files**
+- bin/claude-sync.mjs          — created | unchanged | asked-user
+- scripts/build-hashes.mjs     — created | unchanged | asked-user
+- package.json                 — patched: [bin, files, scripts.build, …]
+- CLAUDE.md                    — section added | skipped (no CLAUDE.md)
+- .dependency-cruiser.cjs      — updated | skipped (not present)
+
+**Manifest**
+- dist/claude-hashes.json: <N> files
+
+**Smoke tests**
+| # | command                                         | expected | actual |
+|---|-------------------------------------------------|----------|--------|
+| 1 | --scope=project --dry-run                       | 0        | <n>    |
+| 2 | --scope=project                                 | 0        | <n>    |
+| 3 | --scope=project (up-to-date)                    | 0        | <n>    |
+| 4 | CI=true --scope=project (tampered)              | 2        | <n>    |
+| 5 | CI=true --scope=project --force                 | 0        | <n>    |
+| 6 | CI=true (missing --scope)                       | 2        | <n>    |
+
+**Isolation**
+- grep on dist/index.{mjs,cjs}: no matches ✓
+- depcheck: <result | "static isolation not enforced">
+
+**Next**: commit on its own — do not bundle with unrelated changes.
+```
+
+## Termination Conditions
+
+- **Pre-Flight fails** → stop, report the failing check. Do not proceed.
+- **Conflict during patch** → stop, show the diff, ask user whether to overwrite.
+- **Build fails at Step 6** → stop, report error. Do not run smoke tests on a broken build.
+- **Smoke test mismatch** → stop, report the failing path with captured exit code.
+- **Bundle grep finds matches** → stop, report which file leaked. Isolation is broken.
+- **All steps pass** → emit the report from the template above.

package/docs/claude/skills/claude-sync-applier/knowledge/claude-md-template.md

@@ -0,0 +1,77 @@
+# `CLAUDE.md` — `## Claude Docs Injector` section
+
+Reference: `packages/canard/schema-form/CLAUDE.md`.
+
+Append the section below to `${TARGET_PATH}/CLAUDE.md` if the file exists.
+Substitute `@canard/schema-form` → `${PACKAGE_NAME}`. Skip the entire step if
+`CLAUDE.md` does not exist (do not create one).
+
+The template is intentionally terse: CLI usage + essential isolation warnings.
+Architectural rationale (three-layer isolation model, silent no-op design,
+stub mechanics) lives in this skill's `knowledge/gotchas.md` — do not
+duplicate it into every consumer's `CLAUDE.md`.
+
+---
+
+## Template
+
+````markdown
+## Claude Docs Injector
+
+Thin CLI stub that injects `docs/claude/` assets into the user's `.claude`
+directory. Engine: `@slats/claude-assets-sync`.
+
+```bash
+npx claude-sync --scope=user                 # ~/.claude
+npx claude-sync --scope=project              # nearest existing .claude walking up from cwd
+npx claude-sync --scope=user --dry-run       # preview
+npx claude-sync --scope=user --force         # overwrite local edits
+
+npx -p @canard/schema-form claude-sync --scope=user  # transitive-dep context
+```
+
+### Isolation Guardrails
+
+- `src/**` MUST NOT import from `bin/**`, `docs/**`, or `@slats/claude-assets-sync`.
+- **Never add `./bin/*` to `exports`.**
+- `yarn depcheck` enforces the isolation in CI.
+````
+
+---
+
+## Substitution Rules
+
+- Replace `@canard/schema-form` with `${PACKAGE_NAME}` (one occurrence, in the
+  `npx -p` line).
+- Preserve the Isolation Guardrails bullets verbatim — these are the sharp
+  invariants that must stay consistent across consumers.
+
+---
+
+## Placement & Skip Conditions
+
+- Append to end of `CLAUDE.md`. Ensure one blank line before the injected
+  section.
+- `${TARGET_PATH}/CLAUDE.md` does not exist → skip, report "skipped (no CLAUDE.md)".
+- Section already present with identical content → skip, report "unchanged".
+- Section present with different content → ask user, do not clobber.
+
+---
+
+## What Was Deliberately Removed
+
+If a previous version of this skill injected a longer template, these parts
+were intentionally dropped:
+
+- Intro paragraph explaining the stub mechanics — belongs in `gotchas.md`,
+  not per-package docs.
+- `--scope=project` cwd-walk blockquote — the comment beside the command is
+  enough.
+- Per-package structure list (`bin/`, `scripts/`, `docs/claude/`,
+  `claude.assetPath` convention) — mechanical, same across all consumers,
+  not useful as per-package documentation.
+- Verbose Isolation Guardrails prose — reduced to three one-line rules.
+
+The principle: per-package `CLAUDE.md` should carry only what an agent or
+human needs **specific to this package**. Shared architecture belongs in the
+skill's knowledge files.

package/docs/claude/skills/claude-sync-applier/knowledge/dependency-cruiser.md

@@ -0,0 +1,126 @@
+# Step 4 — dependency-cruiser isolation gate (optional)
+
+This step is **only** executed when:
+
+- `${TARGET_PATH}/.dependency-cruiser.cjs` already exists (static isolation
+  was previously enforced), OR
+- The user explicitly asks for it.
+
+Do **not** introduce a new `.dependency-cruiser.cjs` into a target package that
+has not already opted into static analysis — the runtime isolation (import
+graph + `sideEffects: false` + no `bin` in `exports`) is sufficient on its own.
+
+**Legacy**: `.dependency-cruiser.js` (not `.cjs`) → out of scope. Flag to user
+and do not rename.
+
+Reference: `packages/canard/schema-form/.dependency-cruiser.cjs`.
+
+---
+
+## Changes to Apply
+
+When applicable, mirror the reference config. Four edits total:
+
+### 1. Append three `forbidden` rules
+
+Append each with `severity: 'error'`:
+
+```js
+{
+  name: 'src-no-bin',
+  severity: 'error',
+  comment:
+    'src/ must not import from bin/. bin/ is a CLI-only entry point and must ' +
+    'never leak into the library bundle.',
+  from: { path: '^src/' },
+  to: { path: '^bin/' },
+},
+{
+  name: 'src-no-docs',
+  severity: 'error',
+  comment:
+    'src/ must not import from docs/. docs/claude/** contains pure markdown assets ' +
+    'meant only for the inject-docs CLI, not for the library runtime.',
+  from: { path: '^src/' },
+  to: { path: '^docs/' },
+},
+{
+  name: 'src-no-claude-assets-sync',
+  severity: 'error',
+  comment:
+    '@slats/claude-assets-sync is a CLI-only dependency. It is allowed only ' +
+    'from bin/. Importing it from src/ would leak the CLI engine into ' +
+    'consumer production bundles.',
+  from: { path: '^src/' },
+  to: { path: 'node_modules/@slats/claude-assets-sync' },
+},
+```
+
+Place these alongside the existing `forbidden` rules in the reference config.
+Do not duplicate if any of these rule names already exist.
+
+### 2. Extend `no-orphans` rule
+
+Add `'^bin/'` to the existing `no-orphans` rule's `from.pathNot` array. `bin`
+entry points are orphans by design (they're invoked as executables, not
+imported).
+
+```js
+from: {
+  orphan: true,
+  pathNot: [
+    '(^|/)[.][^/]+[.](?:js|cjs|mjs|ts|cts|mts|json)$',
+    '[.]d[.]ts$',
+    '(^|/)tsconfig[.]json$',
+    '(^|/)(?:babel|webpack)[.]config[.](?:js|cjs|mjs|ts|cts|mts|json)$',
+    '^bin/',
+  ],
+},
+```
+
+### 3. Expand `options.includeOnly`
+
+Change to include both `src` and `bin` so dependency-cruiser scans the bin
+entry points as well:
+
+```js
+includeOnly: ['^src', '^bin'],
+```
+
+### 4. Add `depcheck` script
+
+In `${TARGET_PATH}/package.json` `scripts`:
+
+```json
+"depcheck": "depcruise src bin --config .dependency-cruiser.cjs --no-progress"
+```
+
+If an existing `depcheck` script points elsewhere, ask the user.
+
+---
+
+## Post-Step Verification
+
+After Steps 1–6 complete and this Step 4 has been applied, Step 9 runs:
+
+```bash
+yarn ${SHORTCUT:-workspace ${PACKAGE_NAME}} depcheck
+```
+
+Must exit 0 with no errors. Pre-existing `no-orphans` warnings are acceptable.
+
+---
+
+## Why This Step Is Optional
+
+The three-layer isolation works without static analysis:
+
+1. Import graph: `src/**` never references `bin/**`, `docs/**`, or
+   `@slats/claude-assets-sync`.
+2. `"sideEffects": false` + `"type": "module"` — dead-code elimination of any
+   accidental reference.
+3. No `./bin/*` in `exports` — consumer bundlers cannot deep-import into bin.
+
+dependency-cruiser adds a fourth layer (CI-time regression detection) but is
+not required for correctness. Don't force-enable it on a package that hasn't
+opted in — it carries real maintenance cost.

package/docs/claude/skills/claude-sync-applier/knowledge/gotchas.md

@@ -0,0 +1,139 @@
+# Invariants and Gotchas
+
+Hard-earned rules. Each one reflects a previous incident or a design
+constraint of the `@slats/claude-assets-sync` engine.
+
+---
+
+## Stubs are verbatim
+
+The `bin/claude-sync.mjs` and `scripts/build-hashes.mjs` files are
+**identical across all consumers** in this monorepo. No per-package
+substitution. Runtime `import.meta.url` (in the bin) and `process.cwd()` (in
+the build script) discover the package root; package metadata is parsed from
+the adjacent `package.json`.
+
+If you find yourself "adapting" the stub for a new consumer, stop — that's a
+sign you misread the design. The engine is generic; the consumer-specific
+convention is the `claude.assetPath` field inside `package.json`.
+
+---
+
+## Silent no-op on missing `claude.assetPath`
+
+Both stubs guard with `if (typeof pkg.claude?.assetPath === 'string')`.
+
+- Missing field → exit 0, produce no output.
+- Non-string value → exit 0, produce no output.
+
+This is the intentional opt-out path: a package can ship the bin and script
+but disable the feature by removing the config field. Do not add "helpful"
+error messages for this case — it would break the opt-out.
+
+---
+
+## `@slats/claude-assets-sync` must be in `dependencies`
+
+**Not** `devDependencies`, **not** `peerDependencies`.
+
+Isolation from the library bundle is enforced by:
+
+1. The import graph (`src/**` never references the engine), and
+2. Optionally, dependency-cruiser static rules.
+
+It is **not** enforced by dependency-type. Placing the engine in
+`devDependencies` would break `npx <pkg> claude-sync` when a downstream
+consumer installs the package — their `npm install` omits dev deps.
+
+---
+
+## Never add `./bin/*` to `exports`
+
+The `exports` map in `package.json` controls which subpaths a consumer's
+bundler can resolve. Leaving `./bin/*` out of `exports` is what prevents a
+bundler from deep-importing the CLI by accident.
+
+Adding `./bin/claude-sync.mjs` to `exports` — even with `"default"` —
+creates a path for a careless `import "@canard/schema-form/bin/claude-sync"`
+to pull the CLI engine (and `@slats/claude-assets-sync`) into the library
+consumer's production bundle. Three-layer isolation collapses to zero.
+
+---
+
+## Do not commit `dist/claude-hashes.json`
+
+It is a build artifact. The `yarn build` chain regenerates it via
+`build:hashes`. It should be in `.gitignore` (usually via a catch-all `dist/`
+rule). If you see it in `git status`, stop — something is misconfigured.
+
+---
+
+## `yarn workspace ${PACKAGE_NAME} build` can fail with `rollup: command not found`
+
+Yarn v4 workspace dispatch does not always propagate the workspace-local
+PATH. Prefer `yarn ${SHORTCUT} build` from the monorepo root, where
+`${SHORTCUT}` is the root-level script alias (e.g. `yarn schemaForm`).
+
+If no shortcut exists, the full form `yarn workspace ${PACKAGE_NAME} build`
+may still work depending on yarn version and cache state — but if it fails
+with `rollup: command not found`, add a shortcut to the root `package.json`
+rather than debugging the nested call.
+
+---
+
+## `--scope=project` walks upward
+
+`--scope=project` walks `process.cwd()` upward looking for an existing
+`.claude` directory. The first one found is reused; if none is found, the
+engine creates one at `cwd`.
+
+Consequence: running the smoke tests from the monorepo root would reuse the
+monorepo's real `.claude`, corrupting it. Always run smoke tests from
+`/tmp/...` with a fresh directory.
+
+---
+
+## Bin paths are orphans on purpose
+
+`bin/claude-sync.mjs` is an executable entry point. It is never imported from
+`src/`. That makes it an orphan in dependency-cruiser's eyes.
+
+Step 4 explicitly excludes `^bin/` from the `no-orphans` rule to silence this
+warning. If you add new bin entry points, extend the `pathNot` pattern — do
+not disable the rule wholesale.
+
+---
+
+## Three-layer isolation — why
+
+1. **Import graph** — `src/**` never references `bin/**`, `docs/**`, or
+   `@slats/claude-assets-sync`. Primary defense.
+2. **`sideEffects: false`** — allows the bundler to tree-shake any accidental
+   reference.
+3. **No `./bin/*` in `exports`** — consumer bundlers cannot reach the bin
+   through subpath imports.
+4. **(Optional) dependency-cruiser** — CI-time regression check that layer 1
+   stays intact.
+
+Step 8 (`grep` on `dist/index.{mjs,cjs}`) is the post-build verification that
+all three primary layers held. Any match → one of them is broken.
+
+---
+
+## Commit this change alone
+
+The change set from this skill touches `bin/`, `scripts/`, `package.json`,
+and possibly `CLAUDE.md` + `.dependency-cruiser.cjs`. It should land in a
+single commit, with no unrelated changes interleaved.
+
+Reasons:
+
+- Easier to revert as a unit if an issue appears downstream.
+- The CI signal (smoke tests, bundle grep) is bound to the state of these
+  files and nothing else.
+- The change is almost entirely mechanical — reviewers can skim-verify
+  against the reference consumer without reviewing business logic.
+
+If the user asks to bundle with other work, push back once: recommend a
+separate commit. If they still want it bundled, proceed but note it in the
+Step 10 report.

package/docs/claude/skills/claude-sync-applier/knowledge/package-json-patches.md

@@ -0,0 +1,130 @@
+# `package.json` Patches
+
+All edits below are **additive**. Existing non-conflicting values remain
+untouched. On any conflicting existing value, stop and ask the user — do not
+overwrite.
+
+Reference: `packages/canard/schema-form/package.json`.
+
+---
+
+## 1. `bin`
+
+```json
+"bin": {
+  "claude-sync": "./bin/claude-sync.mjs"
+}
+```
+
+If `bin` already exists with other entries, merge in the `claude-sync` key;
+preserve siblings. If `bin.claude-sync` already points elsewhere, ask.
+
+---
+
+## 2. `files`
+
+Append `"bin"` to the `files` array if not already present. Order within the
+array is not load-bearing, but to match the reference:
+
+```json
+"files": [
+  "dist",
+  "docs",
+  "bin",
+  "README.md"
+]
+```
+
+If `files` is absent, create it with at least `["dist", "bin"]`, preserving
+any conventions already present in sibling packages.
+
+---
+
+## 3. `scripts.build`
+
+Append ` && yarn build:hashes` to whatever the package currently has.
+
+**Guard against double-append.** If the existing value already ends with
+`yarn build:hashes` or already contains `build:hashes`, leave it alone.
+
+Reference value:
+
+```json
+"build": "rollup -c && yarn build:types && yarn build:hashes"
+```
+
+---
+
+## 4. `scripts.build:hashes`
+
+```json
+"build:hashes": "node scripts/build-hashes.mjs"
+```
+
+If a different `build:hashes` script exists, ask.
+
+---
+
+## 5. `scripts.prepublishOnly`
+
+```json
+"prepublishOnly": "yarn build"
+```
+
+If the target already has a `prepublishOnly` that calls `yarn build`
+(directly or transitively), leave it alone.
+
+---
+
+## 6. `dependencies."@slats/claude-assets-sync"`
+
+**Must be in `dependencies`, never `devDependencies`.**
+
+```json
+"dependencies": {
+  "@slats/claude-assets-sync": "workspace:^"
+}
+```
+
+Rationale: isolation from the library bundle is enforced by the import graph
+(and optionally by dependency-cruiser), not by dependency-type. Placing it in
+`devDependencies` would make `npm install` on a published package fail when a
+consumer runs `npx <pkg> claude-sync`.
+
+If the target already has it in `devDependencies`, move it. Do not duplicate.
+
+---
+
+## 7. `claude.assetPath`
+
+Default value (used when the field is absent):
+
+```json
+"claude": {
+  "assetPath": "docs/claude"
+}
+```
+
+**If `claude.assetPath` already exists with a non-default value, preserve it.**
+The convention lives in the consumer, not the library.
+
+The bin stub guards on `typeof pkg.claude?.assetPath === 'string'` — a missing
+or non-string value is a silent no-op. That is the intentional opt-out path.
+
+---
+
+## Must-NOT
+
+- **Never** add `./bin/*` (or any bin path) to the `exports` field. Leaving bin
+  subpaths unexported is what prevents a consumer bundler from accidentally
+  reaching into the CLI assets via deep imports.
+
+---
+
+## Full Reference
+
+See `packages/canard/schema-form/package.json` for the canonical shape. The
+relevant keys are `bin`, `files`, `scripts.build`, `scripts.build:hashes`,
+`scripts.prepublishOnly`, `dependencies."@slats/claude-assets-sync"`, and
+`claude.assetPath`. Everything else in that file is schema-form-specific and
+must not be copied.