v1.1.0

Added

• Optional Lua operations. Generated operations accept trailing SDK LuaOptional<T> inputs of SDK-supported
  scalar types and one optional trailing out result on a bool binding. Their public surface uses the Client-owned
  LuaOptional<T> and its Omitted, Nil and Of factories; omitted arguments, absent results, explicit nil and
  present values stay distinct. Result mappers run only for present optional values. Existing scalar operation
  signatures stay unchanged.

Changed

• Roadmap status. Historical work items now distinguish shipped implementations, deliberately deferred domains
  and outstanding live qualification or hosted performance evidence.

Security

Deployment

• 1.1 development line. Record the published 1.0.0 public API and analyzer rules as shipped, set the MinVer floor
  and template defaults to 1.1, and regenerate the project-reference lock files. Package validation compares against
  published 1.0.0 packages with strict baseline equality disabled, permitting additive APIs while checking breaks.

Packages

• CheatEngine.Client 1.1.0
• CheatEngine.Client.Abstractions 1.1.0
• CheatEngine.Client.Core 1.1.0
• CheatEngine.Client.Extensions.DependencyInjection 1.1.0
• CheatEngine.Client.Fluent 1.1.0
• CheatEngine.Client.Hosting 1.1.0
• CheatEngine.Client.Templates 1.1.0

The release assets include SHA256SUMS, the SPDX SBOM of each package and their sigstore attestation bundles. RELEASING.md explains how to verify them.

v1.0.0

The first release of CheatEngine.Client: high-level, activation-scoped C# APIs for Cheat Engine 7.7 x64 plugins, built
on CheatEngine.SDK 2.0.0. It fixes the public API for the 1.x line, under the versioning rules of the
README and the
public API charter of the CheatEngine.Client.Abstractions README; an API that carries an experimental diagnostic id
(CECLIENT5001 to CECLIENT5004) stays outside that promise until the id is lifted. Changed and Removed
compare this release with the 0.1.0 builds of the repository, which were never published. They summarize by contract
the changes a consumer of those builds meets, not every renamed member: the PublicAPI files of each project list the
exact surface.

Added

• One client per activation. CheatEngineClientPlugin builds a new DI provider, scope and ICheatEngineClient on
  every enable, starts the ICheatEngineClientModules in registration order, stops them in reverse order and releases
  every Client-owned Cheat Engine resource while the SDK context is still valid. ICheatEngineClient exposes
  Dispatcher, Runtime, Processes, Memory, Patterns, Inspection, Tables, Lua, ValueScans,
  Allocations and Assembly; Epoch and Stopping identify the activation.
• Capability matrix. ICheatEngineRuntime.TryGetClientCapability reports each of the eleven ClientCapabilityIds
  with its Evidence: separate implementation, package, host, live qualification, policy and lifetime gates, and a
  typed EffectiveReasonCode; a capability reports Available only when all six gates are satisfied. Every capability
  has an operational adapter. The package gate accepts a loaded CheatEngine.SDK 2.x at or above 2.0.0, and the
  qualification gate stays Unknown until the Client embeds committed evidence that every live scenario of the
  capability succeeded, none waived (Client.UnsafeLuaExecution has no scenario, so it stays Unknown). The README
  capability tables state the same matrix, and the features Cheat Engine offers without a CheatEngine.SDK primitive are
  listed as not offered.
• Value scans, allocations, instructions and Auto Assembler patches. Four operational adapters, each assigned an
  experimental diagnostic id that keeps its API [Experimental] until the live scenarios of its capability succeed and
  the id is lifted; the README capability tables say which of these ids this release carries. While an API carries its
  id, suppressing the diagnostic is the opt-in, and the diagnostic links to its section of the Abstractions README
  (scope, behavior, known limits and exit criteria):
  • CECLIENT5001, value scans: ICheatEngineClient.ValueScans creates IValueScanSessions over CheatEngine.SDK's
    owned MemScan and FoundList, with first and next scans and pages of at most 1024 copied results;
    ValueScanValue.FromSingle and FromDouble write the value in fixed point with the decimals the caller passes;
  • CECLIENT5002, target allocations: IAllocationClient.Allocate returns an ITargetMemoryLease over
    CheatEngine.SDK's AllocatedRegion (AllocationProtection.ReadWrite or ExecuteReadWrite), freed only in the
    process incarnation that made it;
  • CECLIENT5003, instructions: IAssemblyClient assembles, disassembles and measures one instruction per call,
    checked against the target's instruction profile, and never writes target memory;
  • CECLIENT5004, Auto Assembler patches: IAutoAssemblerClient checks a script, or applies it and returns an
    IAutoAssemblerPatchLease that owns the disable information Cheat Engine returned; it is registered only by
    EnableAutoAssemblerPatches().
• Leases and release outcomes. Every resource the Client creates for the caller is an ICheatEngineLease:
  symbol registrations, Lua modules, value-scan sessions, allocations and Auto Assembler patches. Release() returns a
  LeaseReleaseOutcome (a LeaseReleaseKind, the host effect, and exactly one of IsComplete, IsRetryable and
  RequiresManualRecovery), Dispose() never throws, LastReleaseOutcome keeps the attempt that ended the lease, and
  RequiresManualRecovery says that what the lease owned may remain. Only Unknown and CleanupUnavailable are
  retryable, as in CheatEngine.SDK; a lease still incomplete at disable is reported in the aggregated deactivation
  failure. A target-bound lease exposes the SelectionEpoch of the process CheatEngine.SDK bound it to, and
  ILuaModuleLease.LastModuleReleaseOutcome keeps what the module reported.
• Failure vocabulary. CheatEngineFailure.HostEffect says how far the Cheat Engine primitive got: NotStarted,
  Started, Completed, NotApplied, CleanupUnconfirmed or Unknown. New failure kinds:
  IndeterminateHostResult (documented causes that cannot be told apart, never absence), TargetChanged,
  TargetIdentityUnavailable and RuntimeChanged. CheatEngineFailure.Throw(token) throws a failure's exception and
  ToException(token) creates it.
• Pattern scans. IPatternScanner.ScanDetailed returns a PatternScanOutcome: the classification of TryScan,
  PatternScanMetrics (the route, the host result count, the examined, filtered-out, copied and unread counts, and
  Cheat Engine's scan time apart from the copy time), the PatternScanHostOutcomeKind, the PatternScanRouteReason
  and TargetIdentityVerified. A module or range scan runs Cheat Engine's bounded MemScan on a qualified local target
  and falls back to one global AOBScan with managed filters elsewhere, whose addresses are never reported as
  identity-verified. Scan options are Client values (ScanProtectionFilter, ScanAlignment) that Core translates the
  same way on every route; the default filter is Cheat Engine's empty "find everything" protection text.
• Memory. IMemoryClient.ReadBytesDetailed returns the confirmed prefix of a partial byte read
  (MemoryBytesReadOutcome), and ReadPrimitiveBatchDetailed and WritePrimitiveBatchDetailed report
  RequestedCount, CompletedCount and a MemoryBatchWriteEffectState. Pointer-typed operations use
  CheatEngine.SDK's width-qualified reads and writes at the observed process width, and codec contexts expose Bitness
  and the configured pointer size.
• Runtime and target facts. CheatEngineRuntimeSnapshot groups the four-part Cheat Engine version, the loaded
  CheatEngine.SDK version and whether it is the reviewed package (Version), and the host operating system and
  architecture, CheatEngineBitness, the TargetBackend, the target architecture, TargetBitness and the configured
  pointer size (Platform); a fact CheatEngine.SDK could not establish stays unknown. ProcessSnapshot adds Backend,
  StartTimeUtc and the configured pointer size next to its Bitness (ConfiguredPointerSize,
  ConfiguredPointerSizeBytes, ConfiguredPointerSizeDiffersFromBitness), and IProcessClient.TryGetLocalProcesses
  reads the local process catalog offline, without an activation.
• Address List and symbols. ITableClient counts records (GetRecordCount), reads one by index (GetRecordAt),
  reads the selected record and selects one (GetSelectedRecord, SelectRecord), and loads and saves trusted tables
  through CheatEngine.SDK's CheatTableFiles; a trusted load makes every earlier MemoryRecordId stale.
  IInspectionClient.TryRegisterSymbol registers through CheatEngine.SDK's owned registration after a collision check,
  and TryResolveAddress takes an AddressResolutionMode.
• Lua. Generated Lua modules register through CheatEngine.SDK 2.0.0 registration leases, and the generator reports
  the module shape errors CECLUA1201 to CECLUA1204.
• Fluent entry points. Each domain has one entry point, an extension method bound to its service when the builder
  is created: memory.At(address) and memory.Batch<T>() on an IMemoryClient, and scanner.Aob(pattern) on an
  IPatternScanner. The AOB builder takes typed options (Writable(), WithProtection, AlignedTo, LastDigits,
  WithAlignment), and every terminal documents the exceptions it throws.
• Hosting. CheatEnginePluginBuilder.Logging is the ILoggingBuilder of the activation provider, and
  PluginDirectory is the folder of the plugin assembly, the base for the plugin's own files.
  builder.Logging.AddCheatEngineHostLog() adds an opt-in logging provider that writes to CheatEngine.SDK's host log.
  Event 20 (ActivationIdentified) identifies each activation with the Client version and the consumed and loaded
  CheatEngine.SDK, and event 8 (ExternalLuaStateResetDetected) reports a Lua state that Cheat Engine replaced outside
  the plugin's control, read from CheatEngine.SDK's flag after the Client resources are released, without a snapshot.
• Build diagnostics. The Hosting README catalogs the consumer diagnostics CECLIENT001 to CECLIENT017, and each
  diagnostic carries a help link to its entry.
• Template. dotnet new ceplugin derives the plugin's display name and its Lua status global (ASCII
  lower_snake_case with a _status suffix) from the project name, creates a folder named after the project, honors
  --no-restore and ships a .gitignore. Different project names can derive the same global, which only one plugin
  can own. The generated plugin reads its configuration from PluginDirectory and adds no logging provider; its README
  documents the opt-in AddCheatEngineHostLog().
• Documentation. Every public member documents its parameters, return value and exceptions, which a test checks.
  The packed READMEs are written for plugin authors, and their C# snippets compile against the packed packages. Tests
  also tie the READMEs' 1.0 status columns to the experimental APIs, the diagnostic catalog's severities to the
  diagnostics ...