giles
0b7b3b9efb
Some checks failed
Test, Build, and Deploy / test-build-deploy (push) Failing after 47s
lib/artdag/post.sx — the artdag-side projection for 'a job is a type of post' (per the
host loop). job->post-object: {:type artdag/job :id <output content-id> :wire <dag->wire>},
post-id = content-id = natural AP object id. post-object-verify binds the id to the payload
(record ids recompute + post id present), rejecting tampered params/bogus ids. String
transport for the feed/SXTP body; post-run lets a peer decode->run->result, content-address
cache-hitting. Activity wrapping stays host-side. post 12/12, total 225/225.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
69 lines
2.5 KiB
Plaintext
69 lines
2.5 KiB
Plaintext
; lib/artdag/post.sx — project an artdag job to/from a feed "post object", so a job
|
|
; can ride as the :object of a feed activity ({:actor :verb :object :at :tags}) per the
|
|
; host loop. A post object is content-addressed and self-verifying:
|
|
; {:type "artdag/job" :id <content-id of the output node> :wire <dag->wire>}
|
|
; The :id IS the post/object id (the stable structural digest = natural AP object id);
|
|
; the :wire is the self-describing, write/read-safe payload from serialize.sx whose
|
|
; records each carry their own content-id. The dag<->feed-activity wrapping (actor/verb/
|
|
; at/tags) stays on the host/feed side; this file is only the job<->object projection.
|
|
; Depends on dag.sx + serialize.sx (and execute.sx for post-run).
|
|
|
|
(define artdag/post-type "artdag/job")
|
|
|
|
; a job = a dag + the output node (by author name) the post is "about".
|
|
(define artdag/job->post-object (fn (dag output-name) {:id (artdag/dag-id dag output-name) :type artdag/post-type :wire (artdag/dag->wire dag)}))
|
|
|
|
(define
|
|
artdag/post-object?
|
|
(fn
|
|
(x)
|
|
(and
|
|
(= (type-of x) "dict")
|
|
(= (get x :type) artdag/post-type)
|
|
(has-key? x :id)
|
|
(has-key? x :wire))))
|
|
|
|
(define artdag/post-object-id (fn (post) (get post :id)))
|
|
|
|
(define artdag/post-object-wire (fn (post) (get post :wire)))
|
|
|
|
; integrity: the payload's records each verify (id == recomputed content-id) AND the
|
|
; claimed post id is actually produced by the job (present among the wire records).
|
|
(define
|
|
artdag/post-object-verify
|
|
(fn
|
|
(post)
|
|
(and
|
|
(artdag/post-object? post)
|
|
(artdag/wire-verify (get post :wire))
|
|
(artdag/member?
|
|
(get post :id)
|
|
(map (fn (rec) (nth rec 0)) (get post :wire))))))
|
|
|
|
; decode the payload back into a runnable dag (pure; verify separately, mirroring
|
|
; serialize.sx's wire->dag / wire-verify split).
|
|
(define
|
|
artdag/post-object->job
|
|
(fn (post) (artdag/wire->dag (get post :wire))))
|
|
|
|
; ---- string transport (drop into a feed activity / SXTP body) ----
|
|
|
|
(define
|
|
artdag/job->post-string
|
|
(fn
|
|
(dag output-name)
|
|
(write-to-string (artdag/job->post-object dag output-name))))
|
|
|
|
(define artdag/post-string->object (fn (s) (read (open-input-string s))))
|
|
|
|
; ---- run a received post: decode -> run -> result at the post id ----
|
|
; the peer recomputes the job (content-addressed, so a warm cache hits everything it
|
|
; already has). Returns the result of the output node the post is about.
|
|
(define
|
|
artdag/post-run
|
|
(fn
|
|
(post runner cache)
|
|
(artdag/result-of
|
|
(artdag/run (artdag/post-object->job post) runner cache)
|
|
(artdag/post-object-id post))))
|