Repository navigation
Improving on SplitStr - #47
Merged
Merged
Conversation
Contributor
- Added group forwarding
- Fixed multiple IPs string-jamming issue
AsherBond
pushed a commit
to AsherBond/noflo
that referenced
this pull request
Oct 12, 2026
AsherBond
pushed a commit
to AsherBond/noflo
that referenced
this pull request
Oct 14, 2026
Add a component for converting regular IPs into Assembly messages
bergie
added a commit
that referenced
this pull request
Oct 17, 2026
The firing model follows work document #47 and delivers the semantics trustmaster (Vladimir Sibirov, the Process API's originator) articulated in the #607 discussion, agreed with the maintainer: an arrival on any port re-fires the process once per scope that holds unprocessed input on any port, with the arriving IP — stamped to the firing scope — as the activation's context. - handleIP routes all non-forwarding arrivals through the per-scope walk. The firing predicate is any buffered IP in the scope — data and brackets both, since a closeBracket completing a hasStream wait is a firing edge and openBracket arrivals engage auto-ordering. Forwarding inports are exempt (their brackets are owned by the forwarding machinery). Control ports lose their firing role entirely: their buffers are standing state — the walk skips them, so a control arrival with nothing pending buffers silently. Addressable and IIP buffers join the walk's scan (the IIP buffer was previously invisible to the walk, and addressable pending work was never re-offered). - The 1.x triggering port option is accepted and ignored during the alpha window (removed from the accepted set at 2.0.0). A port declaring it behaves identically to one that does not. - The #607 fixtures rewritten to the component-declares-pattern shape: the firing pattern lives in the has-checks; the engine's job is the wakeup. Assertions are observable (what was consumed and produced), not engine internals (which ports fired). The determinism contract is pinned by spec/FiringModel.js: every permutation of multi-port arrival orders (scoped and unscoped, spread across edges) produces identical outputs and final state. The matrix earned its keep immediately, catching three genuine defects on its first run: - the control-port hasStream wrapper destroyed the bracket-stack walk, so a control stream's completeness gate fired on any partially open stream — the corpus-gate-early shape behind the jekyll footer race; hasStream now takes the framing-aware check on control ports while plain has() keeps the data-presence semantics - the multi-value-config scenario's completion semantics: values arriving after a stream's close do not join an already-fired activation - two read-then-decline deadlocks in the matrix's own scenario code (gate on everything before any consuming read)
bergie
added a commit
that referenced
this pull request
Oct 17, 2026
- The determinism test's load assertion was vacuous (InternalSocket has no component property): wire() returns the component and the assertion reads it directly - The framing state is per walk: ProcessInput.hasStream builds the bracket-walk validator through a factory, and InPort.hasStream walks each buffer (regular, IIP) with fresh state — a partially open regular stream no longer poisons the IIP-buffer check - The forwarding-inport exemption stays intentional (the forwarding machinery owns the brackets and the scenario-C interaction), now documented in the one-rule statement; the matrix's non-coverage is noted in work document #47 - ExtractField guards a non-object message envelope with a kind error instead of a framework TypeError - A debug warning for stream-completeness gating on addressable control ports (the data-presence path cannot see the framing) - CHANGELOG: Changed before Fixed; the one-rule statement precise about control buffers and the forwarding exemption; triggering is removed, not deprecated-ignored - Migration guide: the jammed reference unwound, the one-rule sentence precise
bergie
added a commit
that referenced
this pull request
Oct 18, 2026
…the buffers' remaining work The fanout clone-drop verification (the un-skipped two shapes) revealed the deadlock's precise mechanism — and it was never a clone-drop. The probe showed: every collector firing before the late-arriving standing config declined on the missing precondition; the config's arrival fired exactly ONE round (consuming one pair); and the remaining buffered pairs stranded — no arrival ever comes to wake them. The has-first decline-and-wait model has an incomplete wakeup: arrivals wake, but an activation that CONSUMED input leaves buffered work that nothing wakes. The fix is the firing model's own guarantee (#47: every state change that could satisfy a precondition causes an evaluation) applied to its natural completion: a consumption IS a state change. The drain pump: when an activation that consumed input deactivates, one scheduled offer fires the process for every scope still holding deliverable input. Scheduled (not recursive), so a multi-pair drain chains through macrotasks without stack depth; each offer either consumes (progress) or declines (the buffers unchanged, no further offer) — the pump terminates with the buffers. The ready-scope walk is shared with the arrival walk (handleIP), deduped per scope, and the pump's offer is guarded by the closedown state and the in-flight load. - ProcessContext gains the consumed counter; ProcessInput.get increments it on ownership-moving reads (control reads are non-consuming and do not count) - The two clone-drop tests un-skipped and passing: the unscoped sequential flow drains all pairs (the collector's pairing crossover under reversed async inner delivery is the documented parallel-positional-streams contract, pinned by the test's scope variant); the scoped interleaved flow pairs per scope correctly — the fixture's encoding port needed the standing-config idiom (scoped: false), not an engine change - The bare-class loader finding: fixed — createComponent constructs bare classes with new (detected by prototype.constructor identity and the class source prefix), while factory functions keep the plain-call contract; the registered-factory behavior is unchanged - The wrapAssembly subgraph capability stays open (the sync registry contract vs the async graph-instance harvesting needs its own design pass) — the verification spec pins the gap's current observable The #35 update-#6 sidestep note (bracket-strip before wrapped adapters) can be revisited: the correlation now works
AsherBond
pushed a commit
to AsherBond/noflo
that referenced
this pull request
Oct 19, 2026
…closed-stream strand pin, and the spread-timing matrix - The IIP-buffer check in plain has() could be poisoned by a partially open regular stream: the validator traveled as a bare callback, so the bracket-walk state built during the regular-buffer walk carried into the IIP-buffer walk — an IIP-fed standing value beside an unfinished stream read as being inside brackets. The validator now travels as a factory through the whole has() chain (ProcessInput.has, hasStream, InPort.has), and every buffer walk gets fresh framing state. hasStream's non-control path calls InPort.has directly with its factory — the per-walk item from the follow-up ledger is closed for the control and non-control paths alike - The strand pin: a stream left unclosed (the sender disconnects with the open bracket outstanding) strands its framing, and the port's terminal disconnect reports it. The test documents the discovery that a close-before-open never reaches the buffer at all — the Edge's bracket-integrity validation rejects it at the sender, so the malformed-order class is already handled upstream of the strand diagnostics - The spread-timing matrix variant: arrivals across macrotask gaps produce the same result as back-to-back posting — the shape that makes async components tractable - The per-arrival O(pending scopes) cost stays a noted trade-off of the wakeup-completeness model (recorded in work document noflo#47), closing the last ledger item without code
AsherBond
pushed a commit
to AsherBond/noflo
that referenced
this pull request
Oct 19, 2026
…ent engine Substantial engine work has landed since the document's open items were written (the firing model noflo#47, the scoped liveness noflo#45, bounded edges noflo#38, the deterministic closing noflo#45/noflo#46) — this verification pass checks whether each is still open, against the current engine: - The two skipped fanout-clone-drop tests un-skipped and run: BOTH SHAPES STILL HANG at their timeout — the sequential multi-message clone-drop is real and current. Re-skipped with the fresh evidence; the buffer-lifecycle fix remains the document's central open item - The adapter bracket correlation: VERIFIED WORKING — the spec pins the end-to-end shape the jekyll pipeline sidestepped (concurrent scoped messages with bracketed inner streams pair per message, and the closedown completes on the boundary disconnect). The 'cleaner end state' gap from work document noflo#35 update noflo#6 is closed by the engine work; this spec is now the green pin, not a gap report - The bare-class loader finding: verified still open — the registered bare class throws 'cannot be invoked without new' (the message names the class); the spec pins the current behavior for the fix to flip - The wrapAssembly subgraph capability: verified still open — a graph definition skips with asAssembly's rejection (the observable reason the capability gap carries today)
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.