bendvy-ecs-core Releases (3): 0.1.0.3 0x704c77730661eff4309838fc738ef615 indexed https://jend.leeeet.dev/files.txt?path=bendvy-ecs-core@0.1.0.3 0.1.0.1 0xf435da9e535b3846d643dad16580e35f invalid https://jend.leeeet.dev/files.txt?path=bendvy-ecs-core@0.1.0.1 expected a fresh constructor name (duplicate declaration: Text) At https://jend.leeeet.dev/read.txt?path=bendvy-ecs-core@0.1.0.1/decode_data.bend&start_line=13. Files that do not load: bendvy.bend, bundle_canonical_construction.bend, captured_schedule_query.bend, checked_condition_schedule.bend, declared_family.bend and 161 more. 0.1.0.0 0x296ca5f551e3792cd56cfc8122905b94 invalid https://jend.leeeet.dev/files.txt?path=bendvy-ecs-core@0.1.0.0 expected a fresh constructor name (duplicate declaration: Ready) At https://jend.leeeet.dev/read.txt?path=bendvy-ecs-core@0.1.0.0/execution_trace.bend&start_line=40, https://jend.leeeet.dev/read.txt?path=bendvy-ecs-core@0.1.0.0/machine_handler_engine.bend&start_line=15, https://jend.leeeet.dev/read.txt?path=bendvy-ecs-core@0.1.0.0/ordinary_service_declaration.bend&start_line=16, https://jend.leeeet.dev/read.txt?path=bendvy-ecs-core@0.1.0.0/owned_event_family_reader_query.bend&start_line=25, https://jend.leeeet.dev/read.txt?path=bendvy-ecs-core@0.1.0.0/restore_data.bend&start_line=32. Files that do not load: bendvy.bend, execution_trace.bend, internal/ordinary_component_runner.bend, machine_handler_bundle.bend, machine_handler_context.bend and 44 more. Definitions (3011, 1 to 100 shown): Bendvy.version (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bendvy.bend&name=version) def version() -> String: BundleConstruction.Construction (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_construction.bend&name=Construction) # Experimental reversible constructor RESULT receipts, not a universal Raw->C # inverse or production Decode policy. Only the trusted author supplies undo. type Construction is Type: Constructed{cooked:Cooked,undo:Cooked -> Raw} Invalid{raw:Raw,error:Error} BundleConstruction.Staged (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_construction.bend&name=Staged) type Staged is Type: Valid{context:Context,cooked:Cooked,undo:Cooked -> Raw,positions:List<&2,Maybe<&2,Error>>} Failed{context:Context,raw:Raw,positions:List<&2,Maybe<&2,Error>>} BundleConstruction.undo_pack (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_construction.bend&name=undo_pack) def undo_pack(~HR:Type,~HC:Type,~TR:Type,~TC:Type,headUndo:HC -> HR,tailUndo:TC -> TR,cooked:B.Pack) -> B.Pack: BundleConstruction.constructed_tail (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_construction.bend&name=constructed_tail) def constructed_tail(~Ctx:Type,~HR:Type,~HC:Type,~TR:Type,~TC:Type,~Error:Data,head:HC,headUndo:HC -> HR,tail:Staged) -> Staged,B.Pack,Error>: BundleConstruction.invalid_tail (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_construction.bend&name=invalid_tail) def invalid_tail(~Ctx:Type,~HR:Type,~HC:Type,~TR:Type,~TC:Type,~Error:Data,head:HR,error:Error,tail:Staged) -> Staged,B.Pack,Error>: BundleConstruction.constructed_head (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_construction.bend&name=constructed_head) def constructed_head(~Ctx:Type,~HR:Type,~HC:Type,~TR:Type,~TC:Type,~Error:Data,~stageTail:Ctx -> TR -> Staged,tail:TR,observed:Ctx & Construction) -> Staged,B.Pack,Error>: BundleConstruction.stage (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_construction.bend&name=stage) def stage(~Ctx:Type,~HR:Type,~HC:Type,~TR:Type,~TC:Type,~Error:Data,~constructHead:Ctx -> HR -> Ctx & Construction,~stageTail:Ctx -> TR -> Staged,ctx:Ctx,raw:B.Pack) -> Staged,B.Pack,Error>: BundleConstruction.terminal (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_construction.bend&name=terminal) def terminal(~Ctx:Type,~Error:Data,ctx:Ctx,raw:Unit) -> Staged: BundlePack.Pack (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/bundle_pack.bend&name=Pack) # Arbitrarily nested heterogeneous actual Type owners; no fixed family arity. type Pack is Type: Pack{head:Head,tail:Tail} Capabilities.Read (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=Read) # Closed declaration bundles contain operations, never runtime-owned storage. # Gameplay specializes field projections while threading one abstract owner. # Component read capability: threads opaque owner H and returns Access. # V is detached Data; no affine payload owner or setter is exposed. type Read<-H: Type,-V: Data> is Type: Read{get: H -> H & Cmp.Access} Capabilities.Write (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=Write) # Component read/replacement capability. set consumes payload C and returns # H; it does not itself return rejected C. The bound operation defines error # recording and rollback. Raw constructors are trusted operation adapters. type Write<-H: Type,-C: Type,-V: Data> is Type: Write{get: H -> H & Cmp.Access,set: H -> C -> H} Capabilities.Bundle (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=Bundle) # Heterogeneous pair of grants for the same application capability shape. # Contains operations, not live World storage; nest for additional grants. type Bundle<-A: Type,-B: Type> is Type: Bundle{first: A,second: B} Capabilities.ValueRead (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=ValueRead) # Read capability returning a detached Data value without component Access # wrapping. The supplied operation defines missing-value representation. type ValueRead<-H: Type,-V: Data> is Type: ValueRead{get: H -> H & V} Capabilities.ValueWrite (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=ValueWrite) # Read/replace capability for a Data view V and potentially affine input C. # set consumes C and returns H; no automatic refusal receipt is added here. type ValueWrite<-H: Type,-C: Type,-V: Data> is Type: ValueWrite{get: H -> H & V,set: H -> C -> H} Capabilities.Send (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=Send) # Publication capability consuming C and returning opaque H. The supplied # operation determines staging/refusal/ownership; this wrapper adds no rollback. type Send<-H: Type,-C: Type> is Type: Send{send: H -> C -> H} Capabilities.Action (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=Action) # No-argument operation capability threading one affine opaque owner H. type Action<-H: Type> is Type: Action{run: H -> H} Capabilities.Request (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=Request) # Operation capability consuming C and returning H plus detached Data V. # Use OwnedRequest when the result must itself retain affine owners. type Request<-H: Type,-C: Type,-V: Data> is Type: Request{run: H -> C -> H & V} Capabilities.first (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=first) # Extract the first closed grant from a capability bundle, consuming it. def first(~A: Type,~B: Type,cap: Bundle) -> A: Capabilities.second (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=second) # Extract the second closed grant from a capability bundle, consuming it. def second(~A: Type,~B: Type,cap: Bundle) -> B: Capabilities.read_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=read_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def read_field(~H: Type,~V: Data,cap: Read) -> H -> H & Cmp.Access: Capabilities.write_read_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=write_read_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def write_read_field(~H: Type,~C: Type,~V: Data,cap: Write) -> H -> H & Cmp.Access: Capabilities.write_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=write_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def write_field(~H: Type,~C: Type,~V: Data,cap: Write) -> H -> C -> H: Capabilities.read (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=read) # Invoke a declared component read, returning the owner and Access. # No extra validation is added beyond the bound get operation. def read(~H: Type,~V: Data,~cap: Read,ctx: H) -> H & Cmp.Access: Capabilities.get (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=get) # Read the detached view through a write-capable component grant, returning # H and Access. Does not consume or expose the stored affine C. def get(~H: Type,~C: Type,~V: Data,~cap: Write,ctx: H) -> H & Cmp.Access: Capabilities.set (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=set) # Invoke replacement with consumed C, returning the opaque owner. Refusal # results are determined by the bound operation; rejected C is not returned # by this signature. Canonical grants record errors for enclosing execution. def set(~H: Type,~C: Type,~V: Data,~cap: Write,ctx: H,value: C) -> H: Capabilities.value_read_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=value_read_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def value_read_field(~H: Type,~V: Data,cap: ValueRead) -> H -> H & V: Capabilities.value_write_read_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=value_write_read_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def value_write_read_field(~H: Type,~C: Type,~V: Data,cap: ValueWrite) -> H -> H & V: Capabilities.value_write_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=value_write_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def value_write_field(~H: Type,~C: Type,~V: Data,cap: ValueWrite) -> H -> C -> H: Capabilities.value_read (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=value_read) # Read detached V through ValueRead while returning its opaque owner. def value_read(~H: Type,~V: Data,~cap: ValueRead,ctx: H) -> H & V: Capabilities.value_get (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=value_get) # Read detached V through ValueWrite without replacing its stored value. def value_get(~H: Type,~C: Type,~V: Data,~cap: ValueWrite,ctx: H) -> H & V: Capabilities.value_set (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=value_set) # Consume replacement C through ValueWrite and return the opaque owner. # The bound setter defines transaction/refusal behavior; this adds no receipt. def value_set(~H: Type,~C: Type,~V: Data,~cap: ValueWrite,ctx: H,value: C) -> H: Capabilities.send_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=send_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def send_field(~H: Type,~C: Type,cap: Send) -> H -> C -> H: Capabilities.send (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=send) # Consume input C through a declared send operation and return H. # Publication timing and failure behavior belong to the supplied operation. def send(~H: Type,~C: Type,~cap: Send,ctx: H,value: C) -> H: Capabilities.action_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=action_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def action_field(~H: Type,cap: Action) -> H -> H: Capabilities.action (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=action) # Execute a declared no-argument action, consuming and returning H once. def action(~H: Type,~cap: Action,ctx: H) -> H: Capabilities.request_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=request_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def request_field(~H: Type,~C: Type,~V: Data,cap: Request) -> H -> C -> H & V: Capabilities.request (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=request) # Execute a request with consumed input C, returning H and Data result V. # This is not the affine-output variant; use owned_request for Type results. def request(~H: Type,~C: Type,~V: Data,~cap: Request,ctx: H,value: C) -> H & V: Capabilities.invoke (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=invoke) # One executor for every caller-authored finite capability shape. # Invoke a reusable universally quantified body with Data arguments and # declared Ops(H). H remains opaque to the body; closed caps must implement # the intended operations. This dispatcher adds no transaction or World checks. def invoke(~Ops: Type -> Type,~A: Data,~U: Type,~body: @-H: Type -> @-caps: Ops(H) -> A -> H -> H & U,~H: Type,~caps: Ops(H),args: A,ctx: H) -> H & U: Capabilities.OwnedRequest (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=OwnedRequest) # Additive owned input/result capability; existing Data APIs are unchanged. # Operation consuming an affine Input and returning H with affine Output. # Operation-specific results can preserve refused payloads; the wrapper does # not invent recovery or change their ownership semantics. type OwnedRequest<-H:Type,-Input:Type,-Output:Type> is Type: OwnedRequest{run:H -> Input -> H & Output} Capabilities.owned_request_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=owned_request_field) # Advanced setup projection extracting the closed operation from its grant. # Does not invoke it, access World or grant capabilities beyond that value. def owned_request_field(~H:Type,~Input:Type,~Output:Type,cap:OwnedRequest) -> H -> Input -> H & Output: Capabilities.owned_request (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=owned_request) # Execute with affine input and return H plus the operation's affine # result. Branch on that result to handle payload recovery or refusal. def owned_request(~H:Type,~Input:Type,~Output:Type,~cap:OwnedRequest,ctx:H,input:Input) -> H & Output: Capabilities.invoke_owned (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/capabilities.bend&name=invoke_owned) # Args and output are fixed before opaque H; no Data restriction on owners. # Invoke the universally quantified body with affine arguments/output. # The callback consumes/returns H and consumes A exactly according to its # signature; any error/recovery branches belong to its own output contract. def invoke_owned(~Ops:Type -> Type,~A:Type,~U:Type,~body:@-H:Type -> @-caps:Ops(H) -> A -> H -> H & U,~H:Type,~caps:Ops(H),args:A,ctx:H) -> H & U: ChangeTick.Tick (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=Tick) # Logical change timestamp. low wraps modulo 2^32; epoch preserves the history # needed to age dormant components/readers across low wraps within runtime limits. # Raw constructors are trusted: execution must not supply future stamps/cursors. type Tick is Data: Tick{epoch:Nat,low:U32} ChangeTick.max_change_age (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=max_change_age) # Pinned Bevy ad678262 change_detection/mod.rs MAX_CHANGE_AGE. # Exact epochs replace periodic storage sweeps, not this observable age bound. def max_change_age() -> U32:3258167296 ChangeTick.zero (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=zero) # Initial administrative timestamp. Zero is valid, not component absence or a # fabricated first-run cursor; first-run reader policy is supplied separately. def zero() -> Tick:Tick{0n,0} ChangeTick.incremented (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=incremented) def incremented(wrapped:Bool,epoch:Nat,low:U32) -> Tick: ChangeTick.next (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=next) # Advance one logical execution boundary, carrying the epoch on low-word wrap. def next(tick:Tick) -> Tick: ChangeTick.low (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=low) # Diagnostic low word only; never use this projection as an independent cursor. def low(tick:Tick) -> U32: ChangeTick.total (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=total) # Monotone logical ordinal for existing Nat-based observation/runtime domains. # Backend Nat representation limits still apply to consumers of this projection. def total(tick:Tick) -> Nat: ChangeTick.ordered_epochs (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=ordered_epochs) def ordered_epochs(equal:Bool,earlier:Bool,stamp:U32,this:U32) -> Bool: ChangeTick.not_future (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=not_future) # Explicit validity of a timestamp relative to this execution. Future values # are not made recent by saturating Nat subtraction. def not_future(stamp:Tick,this:Tick) -> Bool: ChangeTick.crossing_age (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=crossing_age) def crossing_age(lowWrapped:Bool,stamp:U32,this:U32) -> U32: ChangeTick.distance (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=distance) def distance(same:Bool,adjacent:Bool,+stamp:U32,+this:U32) -> U32: ChangeTick.valid_age (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=valid_age) def valid_age(valid:Bool,stamp:Tick,this:Tick) -> U32: ChangeTick.age (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=age) # True elapsed age capped at Bevy's MAX_CHANGE_AGE, including multiple wraps. # Invalid future stamps return MAX; use not_future when distinguishing invalid # inputs from legitimately old data. No global storage maintenance is required. def age(+stamp:Tick,+this:Tick) -> U32: ChangeTick.valid_newer (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=valid_newer) def valid_newer(valid:Bool,stamp:Tick,last:Tick,+this:Tick) -> Bool: ChangeTick.newer (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=newer) # Compare component age with independent reader age. Equality and two maximally # old timestamps are not new. A future stamp OR reader cursor rejects as False; # callers separately establish component presence and first-run reader policy. def newer(+stamp:Tick,+last:Tick,+this:Tick) -> Bool: ChangeTick.show (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=show) # Detached full-timestamp diagnostic; the epoch is never discarded. def show(tick:Tick) -> String: ChangeTick.cursor_show (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/change_tick.bend&name=cursor_show) # Distinguish an uninitialized lifecycle cursor from the legitimate zero tick. def cursor_show(cursor:Maybe<&2,Tick>) -> String: Check.Frame (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=Frame) # Trusted declaration setup receives a nominal cursor-free frame. The public # query grant exposes neither lifecycle filters nor added/changed observations. # Machine conditions belong to #55; services/streams have no grant here. # Trusted cursor-free Check frame owning World. Ordinary condition bodies # receive opaque H with read capabilities, not raw world constructors. # No lifecycle cursor or event reader is allocated by this frame. type Frame<-S:Data,-Store:Type,-R:Type,-E:Data> is Type: Frame{world:W.World} Check.PlainSelection (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=PlainSelection) # Condition query membership: Required excludes absent components; Optional # retains live rows with explicit absence. No Added/Changed mode is offered. type PlainSelection is Data: Required{} Optional{} Check.Row (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=Row) # Detached condition-query row: entity handle plus component Access. # Does not expose added/changed flags or an affine component payload. type Row is Data: Row{entity:W.Handle,value:C.Access} Check.Error (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=Error) # Preflight failure listing required runtime resources absent from the plan. # Check body is not invoked when this error is returned. type Error is Data: MissingRuntimeRequirements{resources:List<&2,String>} Check.Plan (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=Plan) # Trusted setup pairing runtime-requirement observation with read grants. # required must return World; arbitrary callback mutations are not isolated # by the Check abstraction. Bodies receive only the declared Ops(H). type Plan<-S:Data,-Store:Type,-R:Type,-E:Data,-Ops:Type -> Type> is Type: Plan{required:W.World -> W.World & List<&2,String>,caps:Ops(Frame)} Check.Checked (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=Checked) # Check outcome retaining World with either a preflight Error or Bool. # False is a successful condition result, distinct from missing requirements. type Checked is Type: Checked{world:W.World,result:Result<&2,&2,Error,Bool>} Check.selection (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=selection) def selection(value:PlainSelection) -> Q.Selection: Check.plain_row (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=plain_row) def plain_row(~S:Data,~V:Data,value:Q.Row) -> Row: Check.plain_rows (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=plain_rows) def plain_rows(~S:Data,~V:Data,values:List<&2,Q.Row>) -> List<&2,Row>: Check.query_done (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=query_done) def query_done(~S:Data,~Store:Type,~R:Type,~E:Data,~V:Data,result:I.Frame & List<&2,Q.Row>) -> Frame & List<&2,Row>: Check.query_read (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=query_read) def query_read(~S:Data,~Store:Type,~R:Type,~E:Data,~Rest:Type,~Payload:Type,~V:Data,~Token:Data,~take:Store -> Rest & Col.Column,~put:Rest -> Col.Column -> Store,~project:Payload -> Payload & V,~family:C.Family,~mode:PlainSelection,frame:Frame) -> Frame & List<&2,Row>: Check.query_grant (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=query_grant) # Build a read-only component query for Required or Optional membership. # Canonical scan returns detached Access rows in its live-handle traversal order, # without lifecycle flags or consuming registered system cursors. project must # preserve payload owners; raw family lenses remain trusted schema setup. def query_grant(~S:Data,~Store:Type,~R:Type,~E:Data,~Rest:Type,~Payload:Type,~V:Data,~Token:Data,~take:Store -> Rest & Col.Column,~put:Rest -> Col.Column -> Store,~project:Payload -> Payload & V,~family:C.Family,~mode:PlainSelection) -> Cap.ValueRead,List<&2,Row>>: Check.resource_done (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=resource_done) def resource_done(~S:Data,~Store:Type,~R:Type,~E:Data,~V:Data,result:W.World & V) -> Frame & V: Check.resource_read (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=resource_read) def resource_read(~S:Data,~Store:Type,~R:Type,~E:Data,~V:Data,~project:R -> R & V,frame:Frame) -> Frame & V: Check.resource_grant (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=resource_grant) # Build read-only access to a detached resource Data view. project threads # affine R back unchanged in ownership; no replacement or event-read grant # is provided and no resource projection runs during declaration construction. def resource_grant(~S:Data,~Store:Type,~R:Type,~E:Data,~V:Data,~project:R -> R & V) -> Cap.ValueRead,V>: Check.completed (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=completed) def completed(~S:Data,~Store:Type,~R:Type,~E:Data,result:Frame & Bool) -> Checked: Check.ready (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=ready) def ready(~S:Data,~Store:Type,~R:Type,~E:Data,~Ops:Type -> Type,~A:Data,~body:@-H:Type -> @-caps:Ops(H) -> A -> H -> H & Bool,~caps:Ops(Frame),args:A,result:W.World & List<&2,String>) -> Checked: Check.required_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=required_field) def required_field(~S:Data,~Store:Type,~R:Type,~E:Data,~Ops:Type -> Type,plan:Plan) -> W.World -> W.World & List<&2,String>: Check.caps_field (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=caps_field) def caps_field(~S:Data,~Store:Type,~R:Type,~E:Data,~Ops:Type -> Type,plan:Plan) -> Ops(Frame): Check.run (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/check.bend&name=run) # Check runtime requirements, then evaluate a cursor-free Bool body through # its declared capabilities. Missing requirements return Checked with Fail # without invoking body; otherwise Done contains True or False. World is # returned on both paths, including any changes made by trusted requirement # callbacks. Check itself advances no system/lifecycle/event cursor or clock. # No automatic transaction rollback applies to arbitrary setup callbacks. # Condition contract and consumers: docs/parity/inspect.md. def run(~S:Data,~Store:Type,~R:Type,~E:Data,~Ops:Type -> Type,~A:Data,~body:@-H:Type -> @-caps:Ops(H) -> A -> H -> H & Bool,~plan:Plan,args:A,world:W.World) -> Checked: ChunkColumn.Column (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=Column) # Trusted storage. Public declarations confine these owners before gameplay runs. type Column<-S:Data,-C:Type> is Type: Leaf{values:Array>,stamps:Array} Branch{half:U32,left:Column,right:Column} ChunkColumn.SwapOutcome (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=SwapOutcome) type SwapOutcome<-S:Data,-C:Type> is Type: Accepted{column:Column,previous:Maybe<&1,C>} Rejected{column:Column,incoming:Maybe<&1,C>} ChunkColumn.absent_generic (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=absent_generic) def absent_generic(-C:Type,depth:Nat) -> Array>: ChunkColumn.empty_generic (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=empty_generic) def empty_generic(-S:Data,-C:Type) -> Column: ChunkColumn.capacity_generic (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=capacity_generic) def capacity_generic(-S:Data,-C:Type,column:Column) -> Column & U32: ChunkColumn.vacant_generic (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=vacant_generic) def vacant_generic(-S:Data,-C:Type,depth:Nat) -> Column: ChunkColumn.grown_generic (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=grown_generic) def grown_generic(-S:Data,-C:Type,fuel:Nat,column:Column,+size:U32,+depth:Nat,+target:U32,enough:Bool) -> Column: ChunkColumn.ensure_sized_generic (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=ensure_sized_generic) def ensure_sized_generic(-S:Data,-C:Type,+target:U32,result:Column & U32) -> Column: ChunkColumn.maximum_capacity (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=maximum_capacity) def maximum_capacity() -> U32:131072 ChunkColumn.ensure_generic (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=ensure_generic) def ensure_generic(-S:Data,-C:Type,column:Column,target:U32) -> Column: ChunkColumn.absent (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=absent) def absent(~C:Type,depth:Nat) -> Array>:absent_generic(C,depth) ChunkColumn.empty (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=empty) def empty(~S:Data,~C:Type) -> Column:empty_generic(S,C) ChunkColumn.capacity (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=capacity) def capacity(~S:Data,~C:Type,column:Column) -> Column & U32:capacity_generic(S,C,column) ChunkColumn.vacant (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=vacant) def vacant(~S:Data,~C:Type,depth:Nat) -> Column:vacant_generic(S,C,depth) ChunkColumn.grown (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=grown) def grown(~S:Data,~C:Type,fuel:Nat,column:Column,size:U32,depth:Nat,target:U32,enough:Bool) -> Column:grown_generic(S,C,fuel,column,size,depth,target,enough) ChunkColumn.ensure_sized (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=ensure_sized) def ensure_sized(~S:Data,~C:Type,target:U32,result:Column & U32) -> Column:ensure_sized_generic(S,C,target,result) ChunkColumn.ensure (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=ensure) def ensure(~S:Data,~C:Type,column:Column,target:U32) -> Column:ensure_generic(S,C,column,target) ChunkColumn.vacancy_restored (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=vacancy_restored) # Actual presence only; None distinguishes unavailable/malformed leaf storage. # Bounds use actual array lengths before any affine cell is temporarily moved. def vacancy_restored(-S:Data,-C:Type,stamps:Array,index:U32,result:Array> & Maybe<&1,C>) -> Column & Maybe<&2,Bool>: ChunkColumn.vacancy_bounded (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=vacancy_bounded) def vacancy_bounded(-S:Data,-C:Type,values:Array>,stamps:Array,+index:U32,valid:Bool) -> Column & Maybe<&2,Bool>: ChunkColumn.vacancy_stamps (https://jend.leeeet.dev/definition.txt?path=bendvy-ecs-core@0.1.0.3/chunk_column.bend&name=vacancy_stamps) def vacancy_stamps(-S:Data,-C:Type,values:Array>,valueSize:U32,+index:U32,result:Array & U32) -> Column & Maybe<&2,Bool>: More: https://jend.leeeet.dev/packages/bendvy-ecs-core.txt?definitions_offset=100