workshopsoft/ludic
2
0
Fork 0
Code Issues Pull requests Projects Releases 26 Packages Wiki Activity Actions

feat(base): 0.R4 - a queue keeps its own count, so every package verb takes only its own state; ludic migrate state --prune

Browse source 
ludic.base's Queue<T> carries a QueueTag (its name and pending count): queue_new(name), q_push(q, v),
q_drain(q), q_clear(q) take no BaseState, and core_undrained(tags) names the given queues still holding
facts. A reducer on a package's state can now call that package's verbs (wallet_earn(wallet_st, n)).

ludic migrate state --prune (ludicc --migrate-prune) takes out each state parameter a function no
longer uses, nor anything it calls, and the argument that fills it - including an argument for a
parameter the callee has dropped, which is taken out before the call is checked, so a generic's T is
told by the argument that says it. A reducer keeps its state. --dry-run now counts the edits it would
make. Every package was moved with it: 608 base_st parameters and their arguments, 1889 edits.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Orkun ÇAKILKAYA 2026-09-26 04:19:56 +03:00
parent 8cf4b3fed6
commit 71735b10a2
151 changed files with 58668 additions and 54719 deletions
Download patch file Download diff file Expand all files Collapse all files

4
packages/ludic.update/latest.ludic
View file

@ -49,7 +49,7 @@ export function update_notes(update_st: UpdateState, lang: string) -> []string {
}
# back to before anything was asked or installed (tests)
export function update_reset(base_st: mut BaseState, update_st: mut UpdateState) -> void {
export function update_reset(update_st: mut UpdateState) -> void {
if update_st.update__ask_h >= 0 { UpdateNet.free(update_st.update__ask_h) }
update_st.update__ask_h = -1
update_st.update__ask = UPDATE_ASK_IDLE
@ -65,5 +65,5 @@ export function update_reset(base_st: mut BaseState, update_st: mut UpdateState)
update_st.update__i = 0
update_st.update__rate = 0
update_st.update__rate_t = -1
q_clear(base_st, update_facts(base_st, update_st))
q_clear(update_facts(update_st))
}

8
packages/ludic.update/state.ludic
View file

@ -87,17 +87,17 @@ function update__conf(update_st: mut UpdateState) -> UpdateConfig {
return update_st.update__cfg
}
export function update_facts(base_st: mut BaseState, update_st: mut UpdateState) -> Queue<UpdateFact> {
if update_st.update__facts == null { update_st.update__facts = queue_new(base_st, "update.facts") }
export function update_facts(update_st: mut UpdateState) -> Queue<UpdateFact> {
if update_st.update__facts == null { update_st.update__facts = queue_new("update.facts") }
return update_st.update__facts
}
function update__fact(base_st: mut BaseState, update_st: mut UpdateState, what: int) -> void {
function update__fact(update_st: mut UpdateState, what: int) -> void {
let f = new UpdateFact
f.what = what
f.error = update_st.update__err
f.target = update_st.update__target
f.packages = update_package_count(update_st)
f.bytes = update_st.update__total_bytes
q_push(base_st, update_facts(base_st, update_st), f)
q_push(update_facts(update_st), f)
}

18
packages/ludic.update/steps.ludic
View file

@ -1,7 +1,7 @@
# steps.ludic - each step started: the feed asked, a package streamed into the packages folder, its
# SHA-256 by a child (Get-FileHash, shasum) so the frame keeps drawing, a patch, the apply
# the Update button: false (and nothing started) when Velopack did not install this copy
export function update_start(base_st: mut BaseState, update_st: mut UpdateState) -> bool {
export function update_start(update_st: mut UpdateState) -> bool {
if not update_installed(update_st) {
update_st.update__err = UPDATE_ERR_NOT_INSTALLED
return false
@ -11,7 +11,7 @@ export function update_start(base_st: mut BaseState, update_st: mut UpdateState)
update_st.update__err = UPDATE_ERR_NONE
update_st.update__h = UpdateNet.get(update__conf(update_st).feed + "/" + update__feed_file())
if update_st.update__h < 0 {
update__fail(base_st, update_st, UPDATE_ERR_UNREACHABLE)
update__fail(update_st, UPDATE_ERR_UNREACHABLE)
return true
}
update_st.update__state = UPDATE_FEED
@ -25,25 +25,25 @@ function update__release(update_st: mut UpdateState) -> void {
update_st.update__proc = -1
}
function update__fail(base_st: mut BaseState, update_st: mut UpdateState, err: int) -> void {
function update__fail(update_st: mut UpdateState, err: int) -> void {
update__release(update_st)
update_st.update__err = err
update_st.update__state = UPDATE_FAILED
update__fact(base_st, update_st, UPDATE_STOPPED)
update__fact(update_st, UPDATE_STOPPED)
}
# fetch file i, unless a copy of the right size is there already - then straight to its check
function update__fetch(base_st: mut BaseState, update_st: mut UpdateState, i: int) -> void {
function update__fetch(update_st: mut UpdateState, i: int) -> void {
update_st.update__i = i
let p = update__path(update_st, i)
if Fs.exists(p) and Fs.size(p) == update_st.update__size[i] {
update__check(base_st, update_st, i)
update__check(update_st, i)
return
}
if Fs.exists(p) { Fs.remove(p) }
update_st.update__h = UpdateNet.download(update__conf(update_st).feed + "/" + update_st.update__files[i], p)
if update_st.update__h < 0 {
update__fail(base_st, update_st, UPDATE_ERR_UNREACHABLE)
update__fail(update_st, UPDATE_ERR_UNREACHABLE)
return
}
update_st.update__rate_t = -1
@ -56,7 +56,7 @@ function update__hash_file(update_st: mut UpdateState) -> string {
}
# no cmd.exe: it parses its own command line and would not survive Process.spawn's quoting
function update__check(base_st: mut BaseState, update_st: mut UpdateState, i: int) -> void {
function update__check(update_st: mut UpdateState, i: int) -> void {
let out = update__hash_file(update_st)
if Fs.exists(out) { Fs.remove(out) }
let args = new []string
@ -72,7 +72,7 @@ function update__check(base_st: mut BaseState, update_st: mut UpdateState, i: in
update_st.update__proc = UpdateProc.spawn("/bin/sh", args)
}
if update_st.update__proc < 0 {
update__fail(base_st, update_st, UPDATE_ERR_CHECK)
update__fail(update_st, UPDATE_ERR_CHECK)
return
}
update_st.update__state = UPDATE_CHECK

106
packages/ludic.update/tests/update_test.ludic
View file

@ -50,7 +50,7 @@ program UpdateTest {
function pkgs() -> string { return dir() + "/packages" }
function hashf() -> string { return dir() + "/hash.txt" }
function fresh(base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState, root: bool) -> void {
function fresh(update_st: mut UpdateState, update_test_st: mut UpdateTestState, root: bool) -> void {
update_test_st.net_answer = -1
update_test_st.net_text = ""
update_test_st.net_urls = new []string
@ -71,7 +71,7 @@ program UpdateTest {
c.packages = pkgs()
c.scratch = hashf()
update_config(update_st, c)
update_reset(base_st, update_st)
update_reset(update_st)
}
function asset(ty: string, ver: string, size: int) -> string {
@ -89,8 +89,8 @@ program UpdateTest {
function seed_base() -> void { Fs.write_text(pkgs() + "/Game-1.0.0-osx-full.nupkg", "base") }
function plan_of(update_st: mut UpdateState, text: string) -> bool { return update_plan(update_st, Json.parse(text)) }
function facts_of(base_st: mut BaseState, update_st: mut UpdateState, what: int) -> int {
let fs = q_drain(base_st, update_facts(base_st, update_st))
function facts_of(update_st: mut UpdateState, what: int) -> int {
let fs = q_drain(update_facts(update_st))
var n = 0
for i in 0 .. len(fs) { if fs[i].what == what { n += 1 } }
return n
@ -107,8 +107,8 @@ program UpdateTest {
expect(not update_newer("0.4.9", "0.5.0"))
}
test "a newer version is shown with its notes, in the language asked for or English" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
test "a newer version is shown with its notes, in the language asked for or English" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
update_check_tick(update_st, false)
expect(last_url(update_test_st) == "http://feed/latest.json")
update_test_st.net_text = "{\"version\":\"1.2.0\",\"notes\":{\"en\":[\"Fish.\",\"Boats.\"],\"tr\":[\"Balik.\"]}}"
@ -120,26 +120,26 @@ program UpdateTest {
expect_eq(len(update_notes(update_st, "de")), 2)
}
test "the version being played is shown only when asked" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
test "the version being played is shown only when asked" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
update_test_st.net_text = "{\"version\":\"1.0.0\",\"notes\":{\"en\":[\"x\"]}}"
update_test_st.net_answer = 1
update_check_tick(update_st, false)
update_check_tick(update_st, false)
expect(not update_shown(update_st))
update_reset(base_st, update_st)
update_reset(update_st)
update_check_tick(update_st, true)
update_check_tick(update_st, true)
expect_eq(update_ask_state(update_st), UPDATE_CURRENT)
update_reset(base_st, update_st)
update_reset(update_st)
update_test_st.net_answer = 0
update_check_tick(update_st, true)
update_check_tick(update_st, true)
expect_eq(update_ask_state(update_st), UPDATE_NONE)
}
test "with the base on disk and every delta there, the plan is the chain, oldest first" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
test "with the base on disk and every delta there, the plan is the chain, oldest first" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
seed_base()
expect(plan_of(update_st, feed(true)))
expect_eq(update_package_count(update_st), 2)
@ -149,8 +149,8 @@ program UpdateTest {
expect(update_target(update_st) == "1.2.0")
}
test "no base, or a missing delta, is the whole newest package" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
test "no base, or a missing delta, is the whole newest package" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
expect(plan_of(update_st, feed(true)))
expect_eq(update_package_count(update_st), 1)
expect(not update_plan_is_delta(update_st, 0))
@ -160,16 +160,16 @@ program UpdateTest {
expect_eq(update_package_count(update_st), 1)
}
test "nothing newer is no plan" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
test "nothing newer is no plan" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
expect(not plan_of(update_st, "{\"Assets\":[" + asset("Full", "1.0.0", 900) + "]}"))
expect(not plan_of(update_st, "{}"))
}
test "a copy Velopack did not install does not start" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, false)
test "a copy Velopack did not install does not start" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, false)
expect(not update_installed(update_st))
expect(not update_start(base_st, update_st))
expect(not update_start(update_st))
expect_eq(update_error(update_st), UPDATE_ERR_NOT_INSTALLED)
Fs.mkdir(dir() + "/Game.app")
Fs.mkdir(dir() + "/Game.app/Contents")
@ -180,93 +180,93 @@ program UpdateTest {
expect(not update_installed(update_st))
}
test "the whole package: fetched, checked, applied, and the game told to go" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
expect(update_start(base_st, update_st))
test "the whole package: fetched, checked, applied, and the game told to go" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
expect(update_start(update_st))
expect(last_url(update_test_st) == "http://feed/releases.osx.json")
update_test_st.net_text = feed(true)
update_test_st.net_answer = 1
update_tick(base_st, update_st)
update_tick(update_st)
expect_eq(update_state(update_st), UPDATE_FETCH)
expect_eq(facts_of(base_st, update_st, UPDATE_STARTED), 1)
expect_eq(facts_of(update_st, UPDATE_STARTED), 1)
expect(last_url(update_test_st) == "http://feed/Game-1.2.0-osx-full.nupkg")
update_test_st.net_got = 500
expect(update_progress(update_st) >= 490 and update_progress(update_st) <= 510)
update_tick(base_st, update_st)
update_tick(update_st)
expect_eq(update_state(update_st), UPDATE_CHECK)
expect(Text.contains(last_args(update_test_st), "shasum -a 256"))
hash_is("AB1.2.0")
update_test_st.proc_code = 0
update_tick(base_st, update_st)
update_tick(update_st)
expect_eq(update_state(update_st), UPDATE_APPLY)
expect(Text.contains(last_args(update_test_st), "apply --silent --waitPid 4242 --package"))
expect(Text.contains(last_args(update_test_st), "--rootDir"))
expect(Text.ends_with(update_test_st.proc_paths[len(update_test_st.proc_paths) - 1], "Game.app/Contents/MacOS/UpdateMac"))
expect_eq(facts_of(base_st, update_st, UPDATE_APPLYING), 1)
expect_eq(facts_of(update_st, UPDATE_APPLYING), 1)
}
test "a wrong hash stops it and deletes the file" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
update_start(base_st, update_st)
test "a wrong hash stops it and deletes the file" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
update_start(update_st)
update_test_st.net_text = feed(true)
update_test_st.net_answer = 1
update_tick(base_st, update_st)
update_tick(update_st)
Fs.write_text(pkgs() + "/Game-1.2.0-osx-full.nupkg", "junk")
update_tick(base_st, update_st)
update_tick(update_st)
hash_is("FFFF")
update_test_st.proc_code = 0
update_tick(base_st, update_st)
update_tick(update_st)
expect(update_failed(update_st))
expect_eq(update_error(update_st), UPDATE_ERR_CORRUPT)
expect(not Fs.exists(pkgs() + "/Game-1.2.0-osx-full.nupkg"))
expect_eq(facts_of(base_st, update_st, UPDATE_STOPPED), 1)
expect_eq(facts_of(update_st, UPDATE_STOPPED), 1)
}
test "a failed download stops it" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
update_start(base_st, update_st)
test "a failed download stops it" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
update_start(update_st)
update_test_st.net_text = feed(true)
update_test_st.net_answer = 1
update_tick(base_st, update_st)
update_tick(update_st)
update_test_st.net_answer = 0
update_tick(base_st, update_st)
update_tick(update_st)
expect_eq(update_error(update_st), UPDATE_ERR_DOWNLOAD)
}
test "the delta chain: each fetched, checked and patched onto the last, then applied" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
test "the delta chain: each fetched, checked and patched onto the last, then applied" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
seed_base()
update_start(base_st, update_st)
update_start(update_st)
update_test_st.net_text = feed(true)
update_test_st.net_answer = 1
update_tick(base_st, update_st)
update_tick(base_st, update_st)
update_tick(update_st)
update_tick(update_st)
hash_is("AB1.1.0")
update_test_st.proc_code = 0
update_tick(base_st, update_st)
update_tick(update_st)
expect_eq(update_state(update_st), UPDATE_PATCH)
expect(Text.contains(last_args(update_test_st), "--old " + pkgs() + "/Game-1.0.0-osx-full.nupkg"))
expect(Text.contains(last_args(update_test_st), "--output " + pkgs() + "/Game-1.1.0-osx-full.nupkg"))
Fs.write_text(pkgs() + "/Game-1.1.0-osx-full.nupkg", "patched")
update_tick(base_st, update_st)
update_tick(update_st)
expect_eq(update_state(update_st), UPDATE_FETCH)
expect_eq(update_index(update_st), 1)
update_tick(base_st, update_st)
update_tick(update_st)
hash_is("AB1.2.0")
update_tick(base_st, update_st)
update_tick(update_st)
Fs.write_text(pkgs() + "/Game-1.2.0-osx-full.nupkg", "patched")
update_tick(base_st, update_st)
update_tick(update_st)
expect_eq(update_state(update_st), UPDATE_APPLY)
expect(Text.contains(last_args(update_test_st), "--package " + pkgs() + "/Game-1.2.0-osx-full.nupkg"))
}
test "a package already on disk at its size is checked, not fetched again" (base_st: mut BaseState, update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(base_st, update_st, update_test_st, true)
update_start(base_st, update_st)
test "a package already on disk at its size is checked, not fetched again" (update_st: mut UpdateState, update_test_st: mut UpdateTestState) {
fresh(update_st, update_test_st, true)
update_start(update_st)
update_test_st.net_text = feed(true)
update_test_st.net_answer = 1
Fs.write_text(pkgs() + "/Game-1.2.0-osx-full.nupkg", Text.repeat("x", 1000))
update_tick(base_st, update_st)
update_tick(update_st)
expect_eq(update_state(update_st), UPDATE_CHECK)
}
}

48
packages/ludic.update/tick.ludic
View file

@ -1,13 +1,13 @@
# tick.ludic - once a frame while an update runs: whatever the step waits on, and the next step
export function update_tick(base_st: mut BaseState, update_st: mut UpdateState) -> void {
export function update_tick(update_st: mut UpdateState) -> void {
update__rate_tick(update_st)
if update_st.update__state == UPDATE_FEED { update__feed_tick(base_st, update_st) }
else if update_st.update__state == UPDATE_FETCH { update__fetch_tick(base_st, update_st) }
else if update_st.update__state == UPDATE_CHECK { update__check_tick(base_st, update_st) }
else if update_st.update__state == UPDATE_PATCH { update__patch_tick(base_st, update_st) }
if update_st.update__state == UPDATE_FEED { update__feed_tick(update_st) }
else if update_st.update__state == UPDATE_FETCH { update__fetch_tick(update_st) }
else if update_st.update__state == UPDATE_CHECK { update__check_tick(update_st) }
else if update_st.update__state == UPDATE_PATCH { update__patch_tick(update_st) }
}
function update__feed_tick(base_st: mut BaseState, update_st: mut UpdateState) -> void {
function update__feed_tick(update_st: mut UpdateState) -> void {
let st = UpdateNet.poll(update_st.update__h)
if st < 0 { return }
var feed: Val = null
@ -15,47 +15,47 @@ function update__feed_tick(base_st: mut BaseState, update_st: mut UpdateState) -
UpdateNet.free(update_st.update__h)
update_st.update__h = -1
if feed == null {
update__fail(base_st, update_st, UPDATE_ERR_UNREACHABLE)
update__fail(update_st, UPDATE_ERR_UNREACHABLE)
return
}
if not update_plan(update_st, feed) {
update__fail(base_st, update_st, UPDATE_ERR_NOTHING)
update__fail(update_st, UPDATE_ERR_NOTHING)
return
}
update__fact(base_st, update_st, UPDATE_STARTED)
update__fetch(base_st, update_st, 0)
update__fact(update_st, UPDATE_STARTED)
update__fetch(update_st, 0)
}
function update__fetch_tick(base_st: mut BaseState, update_st: mut UpdateState) -> void {
function update__fetch_tick(update_st: mut UpdateState) -> void {
let st = UpdateNet.poll(update_st.update__h)
if st < 0 { return }
UpdateNet.free(update_st.update__h)
update_st.update__h = -1
if st == 0 {
Fs.remove(update__path(update_st, update_st.update__i))
update__fail(base_st, update_st, UPDATE_ERR_DOWNLOAD)
update__fail(update_st, UPDATE_ERR_DOWNLOAD)
return
}
update__check(base_st, update_st, update_st.update__i)
update__check(update_st, update_st.update__i)
}
# a package rebuilt from deltas is not compared with the full one's hash: patch re-assembles the
# archive, so the same files come out as different bytes
function update__check_tick(base_st: mut BaseState, update_st: mut UpdateState) -> void {
function update__check_tick(update_st: mut UpdateState) -> void {
let code = UpdateProc.poll(update_st.update__proc)
if code < 0 { return }
UpdateProc.free(update_st.update__proc)
update_st.update__proc = -1
if code != 0 or update__hash_read(update_st) != Text.upper(update_st.update__sha[update_st.update__i]) {
Fs.remove(update__path(update_st, update_st.update__i))
update__fail(base_st, update_st, UPDATE_ERR_CORRUPT)
update__fail(update_st, UPDATE_ERR_CORRUPT)
return
}
update_st.update__done_bytes += update_st.update__size[update_st.update__i]
if update_st.update__delta[update_st.update__i] { update__patch(base_st, update_st, update_st.update__i) } else { update__apply(base_st, update_st, update__path(update_st, update_st.update__i)) }
if update_st.update__delta[update_st.update__i] { update__patch(update_st, update_st.update__i) } else { update__apply(update_st, update__path(update_st, update_st.update__i)) }
}
function update__patch(base_st: mut BaseState, update_st: mut UpdateState, i: int) -> void {
function update__patch(update_st: mut UpdateState, i: int) -> void {
let out = update_packages(update_st) + update__sep() + update_st.update__full[i]
if Fs.exists(out) { Fs.remove(out) }
let args = new []string
@ -69,7 +69,7 @@ function update__patch(base_st: mut BaseState, update_st: mut UpdateState, i: in
push(args, out)
update_st.update__proc = UpdateProc.spawn(update__updater(update_st), args)
if update_st.update__proc < 0 {
update__fail(base_st, update_st, UPDATE_ERR_PATCH_START)
update__fail(update_st, UPDATE_ERR_PATCH_START)
return
}
update_st.update__old = out
@ -77,22 +77,22 @@ function update__patch(base_st: mut BaseState, update_st: mut UpdateState, i: in
update_st.update__step_t0 = UpdateWorld.now_ms()
}
function update__patch_tick(base_st: mut BaseState, update_st: mut UpdateState) -> void {
function update__patch_tick(update_st: mut UpdateState) -> void {
let code = UpdateProc.poll(update_st.update__proc)
if code < 0 { return }
UpdateProc.free(update_st.update__proc)
update_st.update__proc = -1
if code != 0 or not Fs.exists(update_st.update__old) {
update__fail(base_st, update_st, UPDATE_ERR_PATCH)
update__fail(update_st, UPDATE_ERR_PATCH)
return
}
if update_st.update__i + 1 < len(update_st.update__files) { update__fetch(base_st, update_st, update_st.update__i + 1) } else { update__apply(base_st, update_st, update_st.update__old) }
if update_st.update__i + 1 < len(update_st.update__files) { update__fetch(update_st, update_st.update__i + 1) } else { update__apply(update_st, update_st.update__old) }
}
# Velopack waits for this process to be gone, swaps the install and starts the new version; the
# game hears UPDATE_APPLYING and exits. On macOS neither the root nor the packages are where
# UpdateMac would look, so both are named.
function update__apply(base_st: mut BaseState, update_st: mut UpdateState, package: string) -> void {
function update__apply(update_st: mut UpdateState, package: string) -> void {
update_st.update__package = package
let args = new []string
push(args, "apply")
@ -109,9 +109,9 @@ function update__apply(base_st: mut BaseState, update_st: mut UpdateState, packa
}
update_st.update__proc = UpdateProc.spawn(update__updater(update_st), args)
if update_st.update__proc < 0 {
update__fail(base_st, update_st, UPDATE_ERR_APPLY)
update__fail(update_st, UPDATE_ERR_APPLY)
return
}
update_st.update__state = UPDATE_APPLY
update__fact(base_st, update_st, UPDATE_APPLYING)
update__fact(update_st, UPDATE_APPLYING)
}