@neocompose/cli 0.19.2 → 0.19.4

package/skills/neocompose-cli/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Neo Compose CLI"
+  short_description: "Author and synchronize Neo Compose projects"
+  default_prompt: "Use $neocompose-cli to edit and safely synchronize this Neo Compose project."

package/skills/neocompose-cli/references/animation-and-world-authoring.md

@@ -0,0 +1,218 @@
+# Animation and world authoring
+
+Use this reference for world objects, structured leaves, animation, and
+NeoFlow dialogue graphs.
+
+## Contents
+
+- World object contracts
+- Sorting and optional children
+- Structured leaves
+- Animation overrides
+- Segments and tracks
+- NeoFlow dialogues
+
+## World object contracts
+
+Extend visible system world classes with ordinary project-authored classes and
+overrides. Never copy the system schema's `@system` provenance annotation into
+project source.
+
+For world layer links, derive a concrete project class from
+`NeoTileLayerLink` or `NeoObjectLayerLink` and resolve exactly one
+`targetLayer` relation. Do not add value-level target metadata or ask painting
+operations to create/repair relation targets.
+
+## Sorting and optional children
+
+Attach `NeoSortingGroup` as an optional nested member on the project object
+classes that need it:
+
+```neo
+class Tree : NeoObject {
+  public virtual NeoSortingGroup? SortingGroup = null;
+}
+```
+
+Presence of a non-null group makes the object and descendants sort as one unit.
+`SortAtRoot` hoists a nested group against the scene root.
+
+`NeoSpriteObject` exposes `FlipX`, `FlipY`, `MaskInteraction`, and optional
+`SortingOrder`. Treat `SortingOrder` as an offset added to the order derived
+from layer, placement, and composition; it is not an absolute replacement.
+
+Use `NeoObjectBase.Enabled` to hide an object and its entire subtree without
+removing its authored `Children` row. A disabled object is not rendered or
+collided with, but its live values and running animation continue. Prefer this
+for fixed optional equipment/content slots so their provenance and animation
+targets remain stable.
+
+Do not treat P45 runtime-child provenance as available. Runtime structural
+children remain deferred; author known slots and toggle `Enabled`.
+
+## Structured leaves
+
+Address fields of these leaf values:
+
+- `SpriteInfo`: `FileId`, `SliceIndex`
+- Vector values: lowercase components such as `x`, `y`, `z`, `w` where
+  supported by the concrete vector type
+- Color: lowercase `r`, `g`, `b`, `a`
+
+Keep the casing exact. `FileId` and `SliceIndex` are PascalCase; vector and
+color components are lowercase.
+
+Use complete values in normal member initialization:
+
+```neo
+Sprite = Images.Hero.Slice(0);
+Position = new(0, 0, 0);
+Tint = Color(1, 1, 1, 1);
+```
+
+A bare `Images.Hero` yields a file ID only in a file-valued field context.
+Use `.Slice(index)` for a complete `SpriteInfo`.
+
+NeoScript may read or write structured fields when the receiver's effective
+storage permits it:
+
+```neo
+root.Session.Debug.Slice = Leg.Sprite.SliceIndex;
+Leg.Sprite.SliceIndex = 2;
+Leg.Position.y = 0.25;
+Leg.Tint.a = 0.5;
+```
+
+Treat writes as read-modify-write against the current whole leaf. Reject
+unknown fields, vector components unsupported by the concrete type, non-integer
+integer-vector values, and color channels outside `[0, 1]`.
+
+## Animation overrides
+
+Use partial structured literals only inside animation override graphs:
+
+```neo
+Overrides = new {
+  Sprite = new { SliceIndex = 1 },
+  Position = new { y = 0.25 },
+  Tint = new { a = 0.5 },
+};
+```
+
+An empty partial `new { }` means no change. A partial override changes only
+the named fields and preserves the leaf's other current fields. A whole-leaf
+override replaces the whole leaf.
+
+Frame overrides may change `Enabled`, `FlipX`, and `SortingOrder`; they may
+not add, remove, or reorder `Children`.
+
+Address direct children with stable row IDs. Missing optional child slots are
+skipped with diagnostics when the authored slot is absent, while stale
+pre-provenance placements may still fail closed.
+
+A placement row carries its `assetClassId` binding and optional `assetValueId`
+override beside its schema keys. They are row provenance, not declared schema:
+never declare them as members on a project class, and never strip them from a
+row you rewrite.
+
+## Segments and tracks
+
+Use `NeoAnimationSegment<T>` for a frame-indexed value lane. The shipped
+sprite specialization is `NeoSpriteAnimationSegment`, whose
+`NeoAnimationSegmentFrame<SpriteInfo>` rows each provide `Index` and
+`Value`. Sparse frame values hold until the next row or `Duration`.
+
+Use one polymorphic `NeoAnimationClip.Tracks` list:
+
+- `NeoAnimationChildTrack` schedules a child clip selected by `Child` and
+  `ClipKey`.
+- A project subclass of
+  `NeoAnimationSegmentTrack<TChild, TValue>` schedules a segment onto one
+  target member. Implement its abstract `Segment` member as a stored value,
+  lookup, or computed getter.
+- The shipped
+  `NeoSpriteAnimationSegmentTrack<TChild extends NeoSpriteObject>` pairing
+  targets `NeoSpriteObject.Sprite`.
+
+Declare a concrete project track by implementing `Segment`, then construct its
+row with the target child ID:
+
+```neo
+class StoredPantsTrack : NeoSpriteAnimationSegmentTrack<PantsSprite> {
+  public override NeoSpriteAnimationSegment Segment = new();
+}
+
+Tracks = [
+  @id("pants-track-row-id")
+  new StoredPantsTrack(id: "pants-child-row-id") {
+    StartFrame = 0,
+    Direction = .Reverse,
+    OffsetEndIndex = 3,
+  },
+];
+```
+
+Each track has `StartFrame`, `Direction` (`.Forward` or `.Reverse`), and a
+crop window `OffsetStartIndex`/`OffsetEndIndex`. Crop before reversing, then
+schedule on the owning clip. Content beyond the owning clip truncates. Reject
+empty/inverted crop windows and tracks that can never enter the clip.
+
+Treat track target selection as class metadata, not row data. A target must be
+compatible with `TChild` and `TValue`. Track reads and segment getters are
+re-resolved for the next applied frame after a watched dependency changes.
+
+When multiple tracks write the same member in one frame, apply list order and
+let the last write win.
+
+## NeoFlow dialogues
+
+Put exactly one top-level `sealed class Name : Dialogue` in each `.neoflow`
+file. Make it non-generic, derive directly from compiler-owned `Dialogue`, and
+override `Trigger Trigger` exactly once. Do not add any other type declaration.
+
+```neoflow
+@id("capitol-dialogue-id")
+@settings(name: "Capitol: cold boot", saveOptionChoices: true)
+sealed class CapitolColdBoot : Dialogue {
+  @primary Outpost capitol = Assets.Capitol;
+  Player player = Player.Current;
+
+  @id("trigger-id")
+  override Trigger Trigger = new(group: CapitolDialogues.High) => Welcome;
+
+  @id("welcome-node-id")
+  Text Welcome = new(name: "Welcome!") {
+    """
+    Hello, {player.Name}.
+    """
+
+    @id("continue-option-id")
+    Option Continue = new() {
+      """
+      Continue.
+      """
+      return Finish;
+    }
+  }
+
+  @id("finish-node-id")
+  Text Finish = new() {
+    """
+    Until next time.
+    """
+  }
+}
+```
+
+Use `@primary` explicitly; never infer it. Keep dialogue bindings flow-wide and
+node bindings scoped to their node/children. Give each persisted condition use,
+action invocation, mutation, pause, option, and node its own owner-scoped ID.
+
+Use `=> Next` or a trailing block with `return Next;`; do not author a `to:`
+argument. Require destinations for triggers, options, and outcomes. Permit
+terminal text/actions to fall through. Keep all statements for
+`Actions Empty = new();` inside its body.
+
+After editing, run `neo dialogue dryrun <dialogue-ref>`. Exit 1 means the graph
+would fail on device. Use `neo dialogue compile '<logic-block-json>'` only for
+low-level inspection or repair of one logic block.

package/skills/neocompose-cli/references/cli-development.md

@@ -0,0 +1,110 @@
+# CLI development
+
+Use this reference only when changing the CLI, language service, package, or
+the skill itself. Project authors usually do not need it.
+
+## Contents
+
+- Source of truth
+- Feature-spec status
+- Shared implementation contract
+- Package and release maintenance
+- Verification
+
+## Source of truth
+
+Treat the current CLI compiler, shared-language implementation, contract
+registry, tests, and generated corpus as the executable source of truth. Use
+the feature specs to understand intent and edge cases, but do not call the old
+umbrella project-source document complete: it predates P38–P52 and contains
+obsolete authoring examples.
+
+When a spec status header disagrees with released implementation and tests,
+verify the shipped package and implementation PR before teaching the feature.
+
+## Feature-spec status
+
+Read the relevant specs in full:
+
+- [P38 complete schema declarations](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/complete/p38-neo-source-complete-schema-declarations.md)
+- [P39 authored system schema](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/complete/p39-neo-authored-system-schema.md)
+- [P40 sorting and sprite metadata](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/complete/p40-sorting-groups-and-sprite-renderer-metadata.md)
+- [P41 optional object children](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/complete/p41-optional-object-children.md)
+- [P42 structured leaf fields](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/complete/p42-addressable-structured-leaf-fields.md)
+- [P43 initializers and constructors](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/complete/p43-neoscript-initializers-and-constructors.md)
+- [P44 nested-row provenance](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/complete/p44-authored-provenance-for-nested-class-rows.md)
+- [P45 deferred runtime-child provenance](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p45-provenance-for-runtime-children.md)
+- [P46 proposed provenance hardening](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p46-provenance-hardening.md)
+- [P47 same-push references](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p47-same-push-value-references.md)
+- [P48 animation segments](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p48-sprite-animation-segments.md)
+- [P49 required construction](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p49-required-constructors-and-settled-members.md)
+- [P50 loops](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p50-neoscript-for-and-foreach-loops.md)
+- [P51 switch](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p51-neoscript-switch-statements.md)
+- [P52 try/catch](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p52-neoscript-try-catch-blocks.md)
+
+P38–P44 and P47–P51 are implemented. P45 remains deliberately deferred; do not
+build or teach runtime-child provenance. P46 is a hardening proposal, not an
+authoring capability. P52's document header still says proposed, but try/catch
+shipped in CLI 0.18; implementation and parity tests take precedence over that
+stale header.
+
+## Shared implementation contract
+
+Keep parsing, strict resolution, formatting, diagnostics, symbols, and
+NeoScript compilation in the browser-safe `@neocompose/neoscript-language`
+service. Monaco, VS Code, CLI, trusted server, and corpus tooling must consume
+that shared implementation. Do not add language intelligence to one adapter.
+
+Keep project context refreshable without accumulating stale Monaco providers or
+LSP state. Preserve diagnostics, completion, hover, signatures, definition,
+references, rename, symbols, semantic tokens, code actions, and formatting
+parity for `.neo` and `.neoflow`.
+
+Keep trusted server recompilation and verification independent of client
+outputs. The CLI emits a complete source bundle; client-generated IR, structural
+rows, hashes, storage stamps, and pending IDs are not trusted.
+
+## Package and release maintenance
+
+Keep the npm artifact native JavaScript. Do not publish `.csproj`, `.cs`,
+`.dll`, Roslyn host metadata, generated C# SDK output, or trusted server-only
+wrappers.
+
+The marker near the top of `SKILL.md` must exactly match the package version:
+
+```html
+<!-- reviewed-through-cli: 0.19.4 -->
+```
+
+The quoted version above is checked too, so this instruction cannot go stale
+while the skill advances.
+
+For every CLI version bump, audit all behavior and public syntax added since the
+marker, update the skill/references where needed, then advance the marker. Never
+bump it mechanically. `npm run doctor` and package verification both fail when
+it drifts, so the audit lands in the same change as the bump rather than
+blocking a publish after the release has merged.
+
+Every version bump also gets a `CHANGELOG.md` entry, newest first, under a
+`## [version] - date` heading. The same check grades it, so an undocumented
+release fails alongside a stale marker.
+
+Keep `agents/openai.yaml` and every directly linked reference inside the
+published `skills/neocompose-cli/` tree. Keep the frontmatter limited to
+`name` and `description`.
+
+## Verification
+
+Run focused language/compiler tests for changed behavior, then:
+
+```sh
+python3 <skill-creator>/scripts/quick_validate.py cli/skills/neocompose-cli
+npm --prefix cli run test:package
+npm run typecheck
+npm run doctor
+```
+
+Also run contract/corpus checks, Monaco/browser parity, VSIX packaging, and
+interactive sample no-op verification when the corresponding implementation
+surface changes. Run `npm run doctor` last; do not rerun successful suites only
+because doctor formatted files.

package/skills/neocompose-cli/references/commands-and-sync.md

@@ -0,0 +1,130 @@
+# Commands and synchronization
+
+Use this reference for workspace synchronization, conflicts, repair commands,
+branches, releases, history, and authentication.
+
+## Contents
+
+- Pull, inspect, and push
+- Conflicts and files
+- Low-level operations
+- Branches, releases, and history
+- Authentication and automation
+
+## Pull, inspect, and push
+
+Use the high-level source workflow:
+
+```sh
+neo pull
+neo status
+neo diff
+neo dialogue dryrun <dialogue-ref>
+neo push --dry-run
+neo push
+```
+
+Use `neo pull --regenerate-source-names` to refresh readable naming while
+retaining normal merge behavior. Use `--reset` to regenerate canonical source
+and managed binaries. Use `--force` only to discard local edits for the server
+version.
+
+Treat `neo push --dry-run` as a full local commit rehearsal: bundle emission,
+pending-ID assignment on a clone, transport shapes, hashes, and repeat
+verification all run. It also runs the server's preparation phase locally —
+schema-commit materialization, seeded structural rows, and whole-graph
+validation — so a rejection that used to cost a real push and return an opaque
+`preparation-failed` now reports before anything is sent. It does not prompt,
+upload, commit, or rewrite source.
+
+A clean dry-run does not promise a clean push. The workspace holds its
+last-pulled state, so everything that grades the live head is still server-only:
+re-verification of the uploaded bundle bytes, project-file staging, the
+snapshot-id and content-head cross-check, admission classification, chunk
+planning, and finalization. Pull again before pushing if time has passed.
+
+One accepted push atomically commits records, main-locale text, stored bindings,
+and staged file metadata under CAS. Pending durable IDs and source rewrites
+become real only after acceptance.
+
+## Conflicts and files
+
+Resolve source conflicts by editing the final intended source. Use
+`neo resolve --mine` or `neo resolve --theirs` only for a deliberate whole-side
+choice. Pull, inspect, dry-run, and retry; there is no force-CAS path.
+
+For `base-hash-conflict`, pull and merge. For `version-bump-required`, inspect
+the classification and use `neo push --accept-bump` only when the bump is
+intended.
+
+Inspect and stage files with:
+
+```sh
+neo files list
+neo files add <path> [--template <Name>]
+```
+
+Keep local bytes during binary conflict resolution. Inspect the server copy
+under `.neo/conflicts/files/<file-id>/`.
+
+## Low-level operations
+
+Prefer checked-in source for normal authoring. Use low-level commands only for
+automation, repair, or inspection:
+
+```sh
+neo records query [--kind <recordKind>]
+neo records get <kind> <id>
+neo values list [memberId]
+neo values get <valueId>
+neo values set <valueId> '<raw-json-value>'
+neo values bind <staticMemberId> <valueId>
+neo values unbind <staticMemberId>
+neo values create '<raw-json-value>' [--class <classId>] --bind <staticMemberId>
+neo loc locales
+neo loc list
+neo loc set <textId> <locale> "text"
+neo dialogue list
+neo dialogue show <ref>
+neo dialogue compile '<logic-block-json>'
+```
+
+Pass a JSON-array batch on stdin or `--file` where supported so related writes
+remain atomic. A `values set` payload is the raw value, not
+`{ "value": ... }`. Static bind/unbind changes the live binding.
+
+Low-level commands do not rewrite local project source. Run `neo pull` after
+any low-level or web mutation before further source edits or push.
+
+## Branches, releases, and history
+
+```sh
+neo branch list
+neo branch create <name> [--from <ref>]
+neo branch switch <nameOrId>
+neo branch refresh [--dry-run]
+neo merge <branch> [--dry-run] [--migrate]
+neo release cut [--bump major|minor|patch] [--dry-run]
+neo history inspect
+neo history log
+```
+
+Treat branches as copy-on-write forks and releases as immutable snapshots. The
+server derives the minimum compatibility bump; a caller may only raise it.
+Require the release login profile for release operations.
+
+## Authentication and automation
+
+```sh
+neo login [--api <url>] [--profile editor|release] [--save-project <id>]
+neo doctor
+```
+
+The Node CLI talks directly to authenticated Convex APIs through the
+session-gated CAS boundary. Tokens use the OS credential store when available
+and a protected file only as fallback. Use `NEO_COMPOSE_TOKEN` or
+`--token-stdin` in CI. The editor profile cannot publish releases; server
+scopes remain the security boundary.
+
+Pass explicit project/version IDs and flags in automation. Prefer `--json` for
+machine-readable output and do not depend on interactive pickers or confirms.

package/skills/neocompose-cli/references/declarations-and-construction.md

@@ -0,0 +1,217 @@
+# Declarations and construction
+
+Use this reference for schema declarations, annotations, member contracts,
+constructors, and construction-time settlement.
+
+## Contents
+
+- Declaration rules
+- Annotations and settings
+- Member and relation rules
+- Computed initializers and declared constructors
+- Required constructors and settlement
+- Inheritance construction
+
+## Declaration rules
+
+Declare classes, interfaces, and enums only at the top level of definition
+`.neo` files. Do not nest them in a type, body, accessor, lambda, initializer,
+migration, or `.neoflow` file. NeoFlow has its own single-dialogue exception.
+
+Persist the declared identifier as the schema name; there is no separate
+technical/display name. Keep existing IDs stable.
+
+```neo
+@id("interface-named-id")
+interface INamed {
+  @id("named-name-id")
+  string Name { get; }
+
+  @id("named-use-id")
+  void Use(SomeClass context);
+}
+
+@id("class-item-id")
+@storage(allowed: .Immutable)
+abstract class Item<TContext extends SomeClass> : INamed {
+  @id("item-name-id")
+  @settings(localizable: true, searchKey: true)
+  public virtual string Name = "";
+
+  @id("item-use-id")
+  public abstract void Use(TContext context);
+
+  @id("item-load-id")
+  public native async bool Load(TContext context);
+}
+```
+
+Use ordinary `public`, `protected`, `private`, `static`, `virtual`, `abstract`,
+and `override` semantics. Interfaces are non-generic. Do not put `@id` on
+inferred list/dictionary type entries or on derived structural descriptors.
+
+A bodyless function must be `abstract`, `native`, or an interface contract.
+`async` alone does not make it valid.
+
+## Annotations and settings
+
+Never author `@system`. It marks platform-owned system records and is rejected
+on project-authored declarations, members, overrides, values, and files. The
+system types visible in project source may themselves have system provenance;
+that does not authorize copying the annotation onto authored records.
+
+Use context-aware typed annotations:
+
+- `@settings(...)` for localizable/search/index/editor constraints.
+- `@storage(allowed: ...)` on classes and storage keys on members.
+- `@locked` for author-protected declarations supported by the contract.
+- `@hidden` only on a class; absence means visible.
+- `@relations(...)` only on the source class of a specialized direct relation.
+
+Use numeric literals for numeric limits. Keep annotations separate instead of
+inventing a generic metadata bag.
+
+`@index(member: Field, unique: ...)` and
+`@column(member: Field, width: ..., hidden: ..., frozen: ..., wrapContent: ...)`
+are repeatable List annotations. `member:` is a bare field name on the entry
+class. An index accepts a non-localizable string or single-select enum. A column
+may target `__other__` for the default layout of subclass-added fields.
+
+Use `.EnumCase` only when context fixes one enum type; otherwise write
+`EnumType.Case`. Defaults and settings must be statically analyzable.
+
+## Member and relation rules
+
+Infer member kind and optionality from its type and nullability. Treat the
+initializer as its default. Omitted fields materialize their current defaults
+once when an instance is created; later default edits do not mutate existing
+instances.
+
+A lookup member's arity is its declared type. `public Config Config` selects one
+entry and its declared type is the entry type; `public Set<Config> Configs`
+selects several. An initializer body for a single-select lookup returns one
+entry, never a set.
+
+Keep generic project relations as typed top-level declarations in
+`Relations.neo`. Let the compiler derive identities for owned descriptors and
+concrete generic bindings.
+
+For world layer links, instantiate a project-authored descendant of
+`NeoTileLayerLink` or `NeoObjectLayerLink` that resolves exactly one
+`targetLayer` relation. The relation is the complete binding; do not add
+value-level target metadata.
+
+## Computed initializers and declared constructors
+
+Use an expression initializer when a member default must be evaluated during
+construction rather than stored as a closed literal. It runs for every newly
+constructed instance in push, web, and SDK contexts; it does not rewrite
+existing saved instances.
+
+Declare overloadable constructors as members when each constructor body owns
+its parameter scope:
+
+```neo
+class Foo {
+  public string Bar;
+  public bool IsFun;
+
+  public Foo(string bar, bool isFun) {
+    this.Bar = bar;
+    this.IsFun = isFun;
+  }
+}
+
+Foo value = new(bar: "BAR", isFun: true) { IsFun = false };
+```
+
+Constructor parameters are visible only in that constructor body. Do not read
+them from member initializers. Each declared constructor must settle every
+required member on its own; a call-site block cannot repair an invalid
+constructor declaration.
+
+## Required constructors and settlement
+
+Put one required constructor on the class header when the entire class body
+needs the parameters:
+
+```neo
+class Foo(string bar, bool isFun) {
+  public string Bar = bar;
+  public bool IsFun;
+
+  init {
+    if (isFun) {
+      IsFun = true;
+    } else {
+      IsFun = false;
+    }
+  }
+}
+
+Foo value = new(bar: "BAR", isFun: true) { IsFun = false };
+```
+
+Header parameters are in scope throughout the class. Permit at most one `init`
+block. A header constructor disables implicit parameterless `new` and forbids
+additional constructor overloads. Its derived constructor identity is not
+authored with `@id`.
+
+Treat a non-null member with no default as required. Treat a nullable member
+with no default as implicitly `null` and therefore settled:
+
+```neo
+class Result {
+  public string Value;   // required
+  public bool Ok = true; // settled by default
+  public string? Note;   // settled by implicit null
+}
+```
+
+Accept settlement only from:
+
+1. The member's own initializer expression.
+2. Assignment on every reachable path in `init` or a constructor body.
+3. A call-site initializer entry when using an otherwise valid construction
+   path.
+
+Do not infer settlement from a side effect inside another function. Require
+full `if`/`else` coverage when an assignment is conditional.
+
+Apply construction in this order: base construction, member initializers,
+`init` or declared-constructor body, then the call-site initializer block. The
+call-site block wins when it refines an earlier value.
+
+## Inheritance construction
+
+Treat the base clause as a construction expression:
+
+```neo
+class Base(string name) {
+  public string Name = name;
+}
+
+class Child(string name, int rank) : Base(name) {
+  public int Rank = rank;
+}
+```
+
+Call a declared base constructor with `: Base(args)`. When a base has no
+constructor, use a base initializer block to settle required inherited members:
+
+```neo
+class Base {
+  public string Name;
+  public bool Enabled = true;
+}
+
+class Child(string name) : Base {
+  Name = name,
+  Enabled = false
+} {
+}
+```
+
+Bind generic base arguments explicitly when needed. Reject a subclass that
+omits required base arguments or leaves any inherited required member
+unsettled.