Findings — write: creating and updating
How the API behaves in this part of a session. Each rule is the entry's own Teaches, copied whole.
011_create_project
A script user can create a Project with nothing but {"name": ...}, at 201, but the response echoes only 6 attributes, so read the project back if you need anything else.
{"name": "sandbox_show"}withContent-Type: application/jsonis a complete create: 201, no project template, nocode, no dates.On the probed site,
GET /schema/Project/fieldsreturns 42 fields and flags exactly one,name,mandatory: true. That count is site configuration, and a schema flag is not the create contract (probe 012), so it does not establish thatnameis the server's only requirement. This probe never posted a body withoutname; that POST, behind--write, would settle it.Trap. The 201 body is not an entity read. It echoes 6 attributes (
cached_display_name,created_at,landing_page_url,name,tracking_settings,updated_at); everything else,idapart, needs a GET on the new project.nameis flagged both mandatory and unique in the schema, so creating is not idempotent. Probe first (GET /entity/projects?fields=name) and reuse the hit, as this probe does. Custom fields silently become<name>_1on a duplicate (probe 019); whether a Project name collides or duplicates is<unverified>.A fresh project has no
sg_status, so a picker must not filter on it (probe 018).
corpus/findings/011_create_project.md
012_create_version
The schema's mandatory flags are not the create contract: on every project-scoped type measured, project is required and the identity field is optional, server-generated and not unique.
Trap.
/schema/Version/fieldsmarks onlycodemandatory, yet a body withoutproject400s.An entity link is a hash:
"entity": {"type": "Shot", "id": N}creates,"entity": <id>400s.projecttakes the identical shape, and reads return both underrelationships(probe 004).The 201
relationshipsblock lists slots that were never set (cuts,playlists,tags), so its keys are not a record of your input.entityappears only when it was written, the one usable confirmation.Both 400s recorded as
null: the probe capturederrors[0].detailand these errors have none. The status codes are verified; the message text is<unverified>.
The create contract, every type measured since. Version is not a special case. One row per card,
entity_types/<Type>:
| type | identity field | flagged mandatory |
actually required | omitted identity becomes | unique |
|---|---|---|---|---|---|
| Version | code |
yes | no | New Version <id> |
no |
| Shot | code |
yes | no | New Shot <id> |
no |
| Asset | code |
yes | no | New Asset <id> |
no |
| Sequence | code |
yes | no | New Sequence <id> |
no |
| Task | content |
yes | no | New Task <id> |
unmeasured |
| Playlist | code |
yes | no | New Playlist <id> |
no |
| PublishedFile | code |
yes | no | New Published File <id> |
no |
| Note | subject |
yes | no | nothing; the row has no title | no |
| TimeLog | none | only id |
n/a | n/a; description reads New Time Log |
no |
| Delivery | title |
yes | no | New Delivery <id> |
no |
For a project-scoped type, project is the requirement and is flagged mandatory: false; the identity
field is flagged mandatory: true and is optional, generated by the server when omitted. {} and the
identity field alone both answer 400 API create() missing 'project' attribute: with the body echoed.
Nothing is unique on any of them, so keying on code is wrong on every type measured: match on id, and
treat a code lookup as a query that can return more than one row.
Omitting the key and sending an empty one are different. {"code": ""} on a create is 400 code 104
Create failed for [Shot]: Cannot set identifier field to empty. (Shot) (entity_types/Shot), and
Sequence answers the same message for "" and for null (entity_types/Sequence).
Site-wide types are the boundary, not the rule. Project has no project field at all, and its identity
name is the one field flagged both mandatory and unique, so a create there is not idempotent
(entity_types/Project).
editable is the same shape of flag and the same shape of wrong. created_at and updated_at are
flagged editable: false on Note, Reply, Task and Version, and a create body sets both (probe 070).
Neither flag describes the create path; send the body and read the 400.
corpus/findings/012_create_version.md
024_read_after_write
Every write ignores ?fields. A create returns what you sent plus the server defaults, an update returns the whole record, and neither resolves a dotted path, so re-read for those and after an upload.
There is no conditional write.
If-Match,If-Unmodified-SinceandIf-None-Matchare ignored and the update applies at 200, though aGETreturns a weakETag.Echoing
updated_atback is refused withAPI update() Task.updated_at is editable on create only.So a read-then-write guard narrows the race window and never closes it, and exactness needs serialisation outside the API (recipes/005).
| operation | the response returns | it omits | how to get the rest |
|---|---|---|---|
POST /entity/<type> |
the fields of the request body, the server-set ones (created_at, updated_at, cached_display_name), and every relationship as {id, name, type} |
every field left at its default, and every dotted path | GET /entity/<type>/{id}?fields=... |
PUT /entity/<type>/{id} |
the whole record, changed fields and untouched ones alike | dotted paths only | the same follow-up GET |
PATCH /entity/<type>/{id} |
nothing: 404 with a null detail |
everything | use PUT |
batch create row |
the same subset a single create returns | as a single create | one GET per created id |
batch update row |
the whole record, wrapped with links and status |
dotted paths only | the same follow-up GET |
batch delete row |
did_delete, id, uuid |
any field value | nothing to re-read |
_upload complete_upload |
201 with a one-byte body | the stored path and the final URL | poll the field until it stops matching /images/status/transient/ |
DELETE /entity/<type>/{id} |
204, empty body | everything | the id answers 404 from then on |
Trap.
?fieldson a write is accepted and ignored, plain names and dotted paths alike, with no error, the same quiet drop a bogus?fieldsname gets on a read (probe 004).The reported create-versus-update asymmetry is real but inverted: the create response is the thin one. Neither verb resolves
project.Project.nameorentity.Shot.code, and both return the link's ownnameunderrelationships, so a second call is needed only for a linked entity's other fields.On the probed site a Version create answers 9 attributes and 15 relationships and an update answers 52 and 20. The counts are site-specific; the ratio is the rule. A create body of 3 extra fields answered 12 attributes, so the create response is what you sent plus the server defaults, not a fixed list.
A batch endpoint does exist, undocumented:
POST /entity/_batch, and it takes plainapplication/json, not the vendor Content-Type_searchrequires (probe 004).{"requests": [{"request_type": "create", "entity": "Version", "data": {...}}, {"request_type": "update", "entity": "Version", "record_id": N, "data": {...}}, {"request_type": "delete", "entity": "Version", "record_id": N}]}entityis the singular schema name, not the URL slug; the id key isrecord_id, andentity_idis read as 0 and 404s. One failing row rolls the whole batch back: a good create paired with an update of id 999999999 left 0 rows behind. The response isdata, one row per request, in order.Transcoding is the only write whose result is not readable at all on return (probe 013). On the probed site a 16x16 PNG thumbnail stayed at
/images/status/transient/thumbnail_pending.pngpast t+21s and resolved by t+42s, so poll on the path prefix and never on elapsed time.Unsettled. One team reports a newly created Version's linked-entity field reading back empty at the moment of its own creation event, and built a diagnostic to fail loudly on it.
This repo has no event listener, so the claim is untested here and a negative result would prove nothing. Settling it needs a listener reading the entity from inside the event callback and comparing against a read a second later.
corpus/findings/024_read_after_write.md
045_webhooks
The hook contract validates the url and the entity type, and silently accepts a field name, a project id and an entity-type count it will never honour. test_connection answers 204 for any uuid. [partial]
not measured: No entity event reached a hook on the probed site, so the delivery payload, the X-SG-SIGNATURE and x-sg-event-batch-* headers, and batch_deliveries, are all unrecorded.
| sent | result |
|---|---|
a field the type does not have, in update |
201, and the hook can never fire |
| two entity types in one hook | 201 |
| a project id that is not there | 201 |
| an action name the API does not have | 400 entity_types is not valid |
| an entity type the site does not have | 400 entity_types is not valid |
The url validator resolves the host and ignores the scheme. Every unroutable target is refused with one message naming reserved and internal addresses,
https://<name>.example.comincluded, whileftp://example.com/...answers 201. Passing validation means the host resolved, not that the hook can be delivered to.test_connectionanswers 204 for a uuid that is not a hook. It confirms nothing: not that the hook exists, not that the endpoint is reachable, not that anything was sent. Do not use it as a health check.POST /webhook/hooksrefuses the vendor array content type that_searchrequires, at 415 namingapplication/json. The webhook family takes plain JSON only (004_array_vs_hash).The two 404 shapes are the parser, not the lookup: a well-formed uuid that names nothing answers code 104 with
detailnaming it, and a segment that is not a uuid answers code 103 withdetailnull.A delivery record is written whether or not anything answers. A hook pointed at a dead host records
status: "delivered"withresponse_code: 0and an emptybody.deliveredmeans dispatched, not received. Never read that status as confirmation a consumer got the payload; readresponse_code, which is 0 when nothing replied.A hook's own status change is delivered to the hook. Setting
statustodisabledand back writes one delivery record each. Its event type is not in the guide's list of 39 custom events:{"data": {"id": "0", "event_type": "Webhook_Status_Change", "event_log_entry_id": 0, "webhook_status": "disabled", "previous_webhook_status": "active", "meta": {"type": "webhook_status_change", "source": "client", "old_value": "active", "new_value": "disabled"}}, "timestamp": "2026-09-04T18:47:18Z"}idis"0"andevent_log_entry_idis0: this is generated by the webhook service itself and has no row in the event log behind it. A consumer must tolerate it, because no subscription asks for it and every toggled hook is sent one.On the probed site, entity events reach no hook, and this is not a REST problem. A hook created in the web interface and one created over REST behave identically:
active, correctly subscribed, and no delivery record for any entity change or fortest_connection, whileWebhook_Status_Changeon the same hook in the same minute records normally.Two public endpoints were tried, a tunnel proven reachable in-process and webhook.site. So the delivery recorder runs and the entity-event feed into it does not. Diagnose a silent hook by toggling its status: a record proves the pipeline is alive and isolates the fault to the event feed.
Because no entity event was delivered,
X-SG-SIGNATURE, the entity payload, thex-sg-event-batch-*headers,batch_deliveries, andPUT /webhook/deliveries/<record_uuid>andredeliverare all unprobed.Everything here uses
entity_types. The second subscription mode the 400 names,event_type, the fourth lifecycle actionrevive, and the entity families the guide excludes are all measured in050_webhook_subscriptions.
corpus/findings/045_webhooks.md
050_webhook_subscriptions
entity_types and event_type are mutually exclusive and one 400 covers giving neither and giving both. revive is a fourth action, and every entity the guide calls excluded is accepted at 201.
The two modes are exclusive, and one message covers both ways of getting it wrong.
entity_types either entity types or event type is requiredis returned for a body with neither and for a body with both. Read it as "exactly one of these", not as "you are missing one".Every entity the guide calls excluded is accepted at 201. A hook on
ApiUser, onEventLogEntry, or on a connection entity such asAssetShotConnectionis created, isactive, and reads back intact. The documentation says it will never fire. Nothing in the API says so, so the create is not the place you will find out.reviveis a fourth lifecycle action alongsidecreate,updateanddelete, and it is the counterpart to the logical delete in040_field_revive.retireis not an action: the API spells the same operationdelete.A bogus
event_typedoes not enumerate the legal ones.event_type is not validnames nothing, unlike the filter operators, which answer a bogus relation with the full list (017_filter_operators). The 39 custom events are readable from the guide and from nowhere in the API.Type errors on
event_typeare specific where the value error is not: a list answersmust be a stringand an empty string answersmust be filled.batch_deliveriesandvalidate_ssl_certround-trip on create and are readable back.
corpus/findings/050_webhook_subscriptions.md
058_local_storage_roots
One create fills every local_path_* the storage row defines, whichever platform's root the path was under. The server picks the deepest matching root, and no conditional-write header is honoured.
One create fills every platform the row defines. A Mac artist publishing under
mac_pathgives a Linux farm a workinglocal_path_linuxin the same write, and the join runs the same way for a path given under the Linux or Windows root: the server strips whichever root matched and re-joins the remainder onto all three.local_path_windowscomes back with backslashes and the drive letter exactly as the row spells them, even though a backslash in the request is refused (recipes/004_register_published_file).A platform reading null is a root the row leaves unset (probe 021), never a property of the write.
A Windows root is matched with forward slashes.
Z:/zzprobe_058_a/seq/plate.v001.exrresolved againstwindows_pathZ:\zzprobe_058_a, so a client normalises separators before sending and still reaches a drive-letter root.The deepest matching root wins, not the oldest row. With
/zzprobe_058_nand/zzprobe_058_n/subboth defined, a path undersubresolved to thesubrow in both creation orders, so id order does not decide it. Two rows on the identical root resolved to the higher id.A client that means one specific storage sends
{"relative_path", "local_storage"}, which names it outright, rather than{"local_path"}.Nothing in the response signals the choice beyond the id.
path.local_storageandpath_cache_storagehold the same row and there is no confidence, no candidate list and no warning, so a client checks by comparing that id against the storage it intended (recipes/004_register_published_filestep 5).There is no conditional write. All six headers were accepted and ignored, each at 200 with the write applied. The
GETdoes return a weakEtag, so it looks like a precondition is available and no request built on it is honoured. The read-then-write race onversion_numbercannot be closed at the API; it stays a client convention.
corpus/findings/058_local_storage_roots.md
069_client_note
client_note cannot be set over REST: true on create is 400 and any PUT is 400 editable on create only. sg_note_type: "Client" is the one marker a caller can write.
Two refusals, one field. The create path answers Client Notes can not be created through the API, and the update path answers Note.client_note is editable on create only. Read together they
close every route: the only call allowed to set the flag refuses true, and false is what an omitted
key already stores. The schema's editable: false is right here, unlike created_at (probe 070).
sudo_as_login changes nothing; the refusal is on the API, not on the identity.
sg_note_type is what a REST caller can write. Both fields are stock (visible.editable false,
probe 056). sg_note_type is an ordinary list: a value outside valid_values is 400 with the
vocabulary in the error, a PUT is 200, and is filters count it. On the probed site the vocabulary
is Internal and Client; read it from the schema, never assume it. Setting it to Client leaves
client_note false, so a client written this way is invisible to a filter on client_note.
Filter both when listing client-facing Notes. A Note the web application flagged and a Note the
API typed are two disjoint sets: client_note is true finds the first, sg_note_type is "Client"
the second. On the probed sandbox, 0 and 108 rows.
corpus/findings/069_client_note.md
070_authored_timestamps
A create body sets created_at and updated_at and they read back exactly, on Note, Task and Version, though the schema flags both editable false; every PUT on either 400s. [partial]
not measured: Whether an EventLogEntry create can date itself is untried: that row cannot be deleted afterwards (probe 025), so the probe did not spend one.
editable: false does not describe the create path. Both timestamps are flagged editable: false
on all four types and both are accepted in a create body. This is the same inversion probe 012 found on
mandatory, where the one field flagged mandatory on a Note is optional and project, which is not
flagged, is required. The server's own error says which half of the flag is real: is editable on create only, not is not editable. Read editable: false as "not editable by a PUT" and test the create.
| verb | created_at |
updated_at |
|---|---|---|
POST |
stored as sent | stored as sent, on the types that have it |
PUT |
400 is editable on create only |
400 is editable on create only |
An authored date is the real one. It is what the row reads back, what created_at filters and
sorts on, and what less_than selects: nothing keeps a separate wall-clock insert time. An import
writes history that queries correctly, and a bug writes rows that a "created this week" feed can never
see.
null is accepted and leaves the row undated. {"created_at": null} answers 201 and the field
reads back None, so every created_at filter and every sort on it drops the row. Omit the key rather
than sending null on a create built by dropping empty values.
updated_atis not onReplyat all: the create 400s withAPI create() Reply.updated_at doesn't exist.created_atis there and takes a value like the rest.The value shapes are the
date_timewrite shapes exactly (field_types/date_time):ISO 8601with or without an offset, a date-only string meaning midnight UTC, an offset normalised to UTC, and"YYYY-MM-DD HH:MM:SS UTC"refused, which is the spelling the create's own 201 echo uses.The 201 echo and the re-read disagree about the format. Three of the four types echo
2019-03-04 05:06:07 UTC, Task echoesISO 8601, and aGETon any of them returnsISO 8601. Parse the re-read, not the echo.sudo_as_loginchanges nothing here: a person's create dates itself exactly as the script's does.Nothing measured here reaches the event log. A create still writes an
EventLogEntrydated now, and that entry cannot be deleted (probe 025), so a back-dated import leaves a forward-dated audit trail.
corpus/findings/070_authored_timestamps.md
078_page_setting_write
A script cannot create a Page (HumanUser expected), a person can. settings_json writes only as a JSON string, reads back identical. DELETE on a PageSetting is 400: every created row is permanent. [partial]
not measured: What the web interface draws for a person whose override the script wrote: needs a person at a browser. Blocked on the work.
A Page needs a person. A script's create is refused by name (
HumanUser(#...) expected, got ApiUser). Create as a person withsudo_as_login;page_typeis read only and the server fills it (canvas), along with a default tree copied from the type's default page.settings_jsonis written as a string and read as an object. Sendjson.dumps(tree). The server validates nothing past "a string": a value with no widget tree is stored at 200, and a second shared row on one page is accepted, so a writer can leave a page the web interface cannot draw.PageSetting rows cannot be deleted. DELETE is 400
doesn't respond to retirement, and deleting the Page leaves its rows behind withpagereading null. On the probed site 26372 of 30145 PageSetting rows have a null page (probe 023): that is where they come from.This probe therefore clears
settings_jsonto null on every row it leaves, and runs its row-creating half only with--litter.A person's override written by the script is stored and read back like one the web interface wrote. Whether the web interface then draws it was not measured.
On the probed site each run left one PageSetting row,
pagenull andsettings_jsonnull; the runs that measured this finding left 7.
corpus/findings/078_page_setting_write.md
083_task_template_on_create
A create with task_template makes the Tasks inside the same call, by POST and by _batch, copying every field set on the template tasks and their dependency types and offsets.
| on the template task | on the generated Task |
|---|---|
content, step, sg_sort_order, sg_status_list |
copied |
duration, est_in_mins, sg_description, milestone |
copied |
task_assignees |
copied |
start_date, due_date |
copied as the same calendar dates, not shifted |
a TaskDependency with dependency_type and offset_days |
a new TaskDependency between the new Tasks, same type and offset |
| the template task itself | template_task points at it |
task_template |
null on the generated Task; the Shot holds it |
project, entity |
the Shot's project, the Shot |
The Tasks exist before the 201 returns: a read straight after the create found all three, and one 5s later found the same three. There is no background job to poll for.
The 201 body's
tasksrelationship is[]although the Tasks exist. Read them with["entity", "is", <the Shot>]on/entity/tasks/_search, not off the create response._batchapplies the template exactly asPOSTdoes. Recipe 002's rule still holds: the batch cannot name the Tasks it generates, so read them back afterwards.entity_typeon the template is not checked: anAssettemplate on a Shot create generated its Task.Dates copy verbatim. A template task dated in March makes a March Task on every entity, whatever day it is created; schedule them afterwards (probe 087 for what a date write then moves).
Reapplying to a Shot that already has Tasks is probe 084.
corpus/findings/083_task_template_on_create.md
084_task_template_reapply
Changing task_template to T creates a Task per T task no Task links by template_task, duplicating a same-name hand-made one, and re-syncs the linked Tasks' fields and edges (probe 102).
| on the Shot already | the new template's task | result |
|---|---|---|
| nothing | any | created |
a Task whose template_task is this template task |
the same | not re-created; re-synced to it, fields and edges (probe 102) |
a Task made from another template, same content and step |
this one | created: a duplicate |
a Task made from another template, same content, other step |
this one | created |
a hand-made Task, same content and step |
this one | created: a duplicate |
| a Task from the old template the new one lacks | none | kept |
The match key is
template_task, notcontentandstep. A template task is not re-created only when a Task on the entity already points at it. Delete that Task and the next apply re-creates it.No Task is ever removed. Switching templates, and clearing the field, leave every Task in place, statuses and all. A replace means the caller deletes the Tasks itself (probe 089 for what that breaks).
It does not only add. The Tasks linked to the new template have their fields overwritten and the edges between them reset to the template's (probes 096, 102 correct this entry's first reading).
The apply runs only when the value changes. Sending the stored value again added nothing on Shot E although a Task was missing; clear the field first, then set it, as Shot D did.
There is no mode. No body key, schema property or documented parameter selects keep, replace or merge. To merge by
contentandstep, point each matching Task'stemplate_taskat its template task first, then writetask_template(recipe 015_apply_task_template_without_duplicates).
corpus/findings/084_task_template_reapply.md
085_task_dependency_types
TaskDependency takes four dependency_type values, default finish-to-start-next-day; offset_days counts working days and snaps the dependent both ways. shift_ratio moved nothing.
dependency_type |
the dependent Task (task) is placed so that |
|---|---|
finish-to-start-next-day |
it starts the working day after dependent_task ends |
start-to-start |
it starts the day dependent_task starts |
finish-to-finish |
it ends the day dependent_task ends |
start-to-finish-next-day |
it ends the working day before dependent_task starts |
The field names read backwards.
taskis the downstream Task anddependent_taskis the one it depends on: the row readsTask <task> dependent on Task <dependent_task>, andtaskgetsdependent_taskin itsupstream_tasks.offset_daysis working days on top of the type and may be negative:finish-to-start-next-daywith 2 moved Monday to Wednesday, with -1 it put a start on the upstream's Friday and its end on the next Monday.The dependent snaps to the constraint in both directions. Every D started two weeks early and was moved later; setting
offset_daysback to null moved a D earlier. It is placement, not a minimum.PUTon a live row reschedules at once, so a type or offset can be corrected in place.shift_ratio0.5 was accepted with 201 and changed no date in any of the four types. Its effect is unmeasured beyond that.The server rejects a duplicate pair, a self-loop and a two-Task cycle with a 400; a three-Task cycle is the same 400, inside
_batchtoo (probe 107).pinnedstayed false throughout (probe 087 for pinned Tasks).offset_daysnull and 0 place the Task alike but are two stored values: a filter on one misses the other, and a template apply treats them as a difference (probe 105).
corpus/findings/085_task_dependency_types.md
086_batch_tasks_with_dependencies
Tasks and their dependencies take two _batch calls: create the Tasks, then create TaskDependency rows. upstream_tasks on a create links without rescheduling.
| route | calls | dependency type | dependents scheduled |
|---|---|---|---|
| one batch with a placeholder id | 1 | n/a | 400, nothing created |
Task creates, then TaskDependency creates |
2 | any, with offset_days |
yes |
Task creates, then upstream_tasks updates |
2 | finish-to-start-next-day only |
yes |
level by level, upstream_tasks in the create body |
one per level | finish-to-start-next-day only |
no |
A link made at create time does not schedule.
upstream_tasksin a create body, batched or not, writes the TaskDependency row and leaves the dates as sent, withdependency_violationfalse. A later write to another field does not fix them. Write the link as a separate update or row."entity": "TaskDependency"is a valid batch entity, so route 1 is the one that takes a type and an offset: it is how to copy a template's edges (probe 085 for what each type does).A loop in a dependency batch rolls the whole batch back like any other failure (recipe 002).
Recipe 016_create_tasks_with_dependencies is route 1 as code.
corpus/findings/086_batch_tasks_with_dependencies.md
087_dependency_cascade
An upstream date write reschedules every unpinned downstream Task, later and earlier alike; a null one moves none (097). A pinned Task stays put and flags dependency_violation while broken.
| the downstream Task | after an upstream date write |
|---|---|
| unpinned, any depth | moved to satisfy its dependency, later or earlier, duration held |
start-to-start |
follows the upstream start; untouched by a due date write |
pinned true |
dates held; dependency_violation true while broken, false again once satisfied |
| downstream of a pinned Task | follows the pinned Task, not the upstream end of the chain |
finish-to-start, when a Task with no upstream has its dates written null |
unmoved; the next real date write moves it (probe 097) |
The cascade pulls back as well as pushes. Shortening the upstream moved d1 and d2 earlier. A Task whose dates a person chose and did not pin is overwritten by any upstream write, and by a new edge (probe 092).
Writing a dependent's
start_datepins it. The datePUTon d1 setpinnedtrue (asentity_types/Taskfound) and d2 followed d1 to a date before the upstream ends. ThatPUTwrotestart_date; probe 093 foundstart_dateis what pins, null or real, and adue_datewrite alone does not. Adurationwrite does not (probe 100); a Task with no upstream never pins (probe 097).PUT {"pinned": false}reschedules at once: d1 snapped back behind the upstream and d2 with it.pinnedis writable directly, so a sync can protect a Task before it rewrites the upstream end.
corpus/findings/087_dependency_cascade.md
089_task_delete_side_effects
Deleting a Task retires its TaskDependency rows, unlinks both neighbours without bridging them, and nulls Version.sg_task and PublishedFile.task. Revive restores all of it.
| linked to the deleted Task | after DELETE |
after revive |
|---|---|---|
| its TaskDependency rows | retired: 404 on GET, listed under return_only: retired |
live again |
| the upstream and downstream neighbours | unlinked from it; not linked to each other | relinked |
| the neighbours' dates | unchanged | the chain rescheduled from the upstream's current dates |
Version.sg_task |
null; the Version stays |
the Task again |
PublishedFile.task |
null; the file stays |
the Task again |
A PublishedFile loses its Task and nothing says so. The file stays live with
tasknull, so a["task", "is", ...]query stops finding it and the publish reads as an orphan. Read what points at a Task before deleting it; the 204 names nothing.The chain is cut, not bridged.
cstopped followinga: movingaafterwards leftcwhere it was. A sync that removes a middle Task must write thea -> cdependency itself if it wants one.Revive is a full undo on the links measured here: dependencies,
sg_taskandtaskall returned with the same row ids. The revived chain is rescheduled at once, so its dates are not the ones it was deleted with.A
deleterequest inside_batchdoes the same to the Task, its dependency rows, its neighbours andVersion.sg_task, and revive undoes it the same way (probe 103).PublishedFile.taskwas not measured on that route.Deleting a Task retires only the Task and its dependency rows, unlike deleting a Shot, which retires its Versions (probe 060).
corpus/findings/089_task_delete_side_effects.md
092_dependency_edge_reschedule
A new edge reschedules an unpinned downstream Task at once, whether POSTed or copied by a template apply on claim. A pinned one keeps its dates and flags dependency_violation.
An edge is a scheduling write. Creating one moves an unpinned downstream Task to satisfy it, the same as the upstream date write of probe 087,
durationheld. The upstream Task does not move.A template apply reschedules Tasks it did not create. The edge it copies between claimed Tasks (recipe 015) moved
btwo days although no date was sent. Pin a Task whose dates a person chose before the apply, or restore its dates after.A pinned downstream Task keeps its dates and reads
dependency_violationtrue from the moment the edge exists. Neither route sets or clearspinned.The claim itself (
template_taskwritten) moves nothing, and the reschedule is done before thePUTreturns: a read 3 s later matched the first. The template's undated tasks copied no dates.
corpus/findings/092_dependency_edge_reschedule.md
093_clear_dates_pin
On a dependent Task a start_date write pins it, null or real; a due_date write never does, null or real. A pinned null Task holds; PUT pinned:false refills both dates.
| write on a dependent Task | pinned after |
on the next upstream write |
|---|---|---|
start_date null, alone or with due_date |
true |
held; the null stays null, dependency_violation stays false |
start_date real |
true (control) |
held; dependency_violation true |
due_date null alone |
false |
follows: both dates rewritten from the upstream and duration |
due_date real |
false (control, twice); duration recomputed |
follows, new duration kept |
PUT {"pinned": false} |
false |
rewrites start_date from the upstream, due_date from duration |
start_dateis the pinning write, not "any date". The same Task (due) stayed unpinned afterdue_datenull and after a realdue_date, then pinned on a realstart_date. Adue_datewrite acts like adurationwrite (probe 100): it resizes, it does not anchor.Nothing unpins a Task by itself:
bothandstartstayed pinned with a null start across the upstream move. A null start raises nodependency_violation, so it is invisible to a violation check.durationsurvives every null write (960 throughout); the unpin recompute uses it to refilldue_date.A sync that wants the server to reschedule a Task sets
pinned: false; nulling the dates either pins it (start_date) or is overwritten at the next upstream write (due_date).
corpus/findings/093_clear_dates_pin.md
094_permission_preflight
Ask with a write that cannot land: a no-op PUT per field (update), a POST with a bad status (create), a _batch of [delete, 404 sentinel] (delete). Permission is checked first, and nothing is written. [partial]
not measured: a launcher session (probe 052) of a lower-level person, and the allowed side of a conditional rule (an Artist assigned to the Task); both need a person, the first at a browser
Every refusal is a 400 naming the entity or the field, checked before value validation and before the batch reaches its next request. An allowed caller gets the validation error or the sentinel's 404 instead. Nothing reaches the rows either way: no updated_at bump, no EventLogEntry, no retired row.
properties.editableinGET /schema/<Type>/fields?project_id=is per caller.falseis a refusal without a write.truecan still be refused by a conditional rule (candidate 3), so it means maybe.Candidates 5, 7 and 8 answer the same for both callers and test nothing: an empty PUT passes, and an unknown field or a missing id fails before permission is read.
A no-op PUT tests the current value. A rule can depend on
field_value, so test the intended value with a_batchof [the real update, sentinel] (candidate 11), which rolls back.
Callers. The refused person and the allowed person are the script acting through sudo_as_login
(probe 027), which applies that person's permission set. A person signed in with the App Session
Launcher (probe 052, recipe 012) has the same set on a HumanUser bearer; that session was not
measured as an Artist, because the launcher needs the person to approve at a browser.
Precondition, declared. The probe provisions its rows. It cannot provision the refused caller:
can_impersonate_this_user is not writable over REST (probe 027). Its requires list names an active
non-Admin HumanUser with that flag on and in the sandbox project, found by a _search, and the probe
exits with the list when there is none. On the probed site two Artists qualify.
A conditional refusal prints its rule. Probe 027 found no rule readable as a row. The 400 for a
conditional rule returns the rule id and its condition tree: on the probed site an Artist may set
Task.sg_status_list only where task_assignees or task_reviewers (or a Group in either) holds the
caller. An unconditional refusal names only the field.
A late bump on a rolled-back create. In exploratory runs of the same _batch [create a Task under a
Shot, sentinel] by an allowed caller, the parent Shot's updated_at moved a few seconds after the call
in 4 of 15 rolled-back creates, with updated_by unchanged, no EventLogEntry and no Task. The run above
saw none; one earlier probe run saw one. No other candidate moved a timestamp in any run. Check create
with the invalid-status POST (candidate 6), which left its parent unchanged in all 3 probe runs.
Unmeasured. An Artist assigned to the Task, which is the allowed side of the rule in candidate 3:
assigning a real person can notify them. Delete is checked per entity type here; a conditional delete
rule would need the same _batch per row. Assets were read in the schema only; the PUT candidates ran
on a Shot.
corpus/findings/094_permission_preflight.md
095_dependency_remove_undo
Remove an edge with DELETE on its TaskDependency row: revive restores its type and offset. A remove on upstream_tasks or downstream_tasks erases the row for good.
| remove by | the TaskDependency row | undo |
|---|---|---|
DELETE /entity/task_dependencies/<id> |
retired: 404 on GET, listed under return_only: retired |
POST .../<id>?revive=1, same id, type and offset |
a delete request on the row inside _batch |
retired, the same (probe 103) | revive, the same |
remove on the downstream Task's upstream_tasks |
erased: not listed as retired | re-create; revive is 404 |
remove on the upstream Task's downstream_tasks |
erased, the same | re-create; revive is 404 |
| the downstream Task | after the edge is removed | after revive or re-create |
|---|---|---|
| unpinned | dates held where the edge put them; no longer follows the upstream | rescheduled at once from the upstream's current dates |
| pinned, in violation | dates and pinned held; dependency_violation false |
dates held; dependency_violation true again |
Delete the row, not the link. An undo stack that removes an edge by a
multi_entityremovecannot bring it back: the row is gone, and re-adding throughupstream_taskswrites a new row typedfinish-to-start-next-daywith no offset. Record the row id and delete it, byDELETEor in_batch.A re-created row with the same type and offset places the Task as the revived row would. The difference is the id, and the retired original then cannot be revived: the pair is unique across live rows, so revive after re-create is the 400 above. Undo by revive, or by re-create, not both.
Neither route restores the downstream Task's old dates. An unpinned Task snaps to the edge as measured against the upstream now (probe 085); an undo that wants the old dates writes them, and the
start_datewrite pins the Task (probe 093).An edge places an unpinned Task exactly, not at the earliest: l1 and l3, written late, were pulled back to the edge. A pinned Task placed later than that reads
dependency_violationfalse for both types (l2, l4); only one placed earlier (d) reads true.
corpus/findings/095_dependency_remove_undo.md
096_task_template_unmerge
A template write re-syncs every Task linked to it: fields but status reset, edges rewired. Undo: old template_task per Task first, then old task_template, then delete what B made.
| write | server does |
|---|---|
template_task on a Task |
nothing but that field |
task_template changed to T |
for every Task pointing at a T task: sg_sort_order, sg_description, duration set to the template task's; sg_status_list kept |
| the same | creates the Tasks no Task points at (probe 084), adds T's missing edges, deletes edges between two T-linked Tasks that T lacks, moves an edge to the Task that now holds its template end |
task_template null |
nothing: no field, Task or edge touched |
The apply overwrites hand edits. It re-syncs every linked Task, not only the new ones:
roto, never claimed, lost its description and duration. This corrects probe 084's "skipped" and recipe 015, which says onlytemplate_taskis written. Status is the one field measured to survive.Order: Tasks first, then the entity. Entity first, A's apply finds its tasks unclaimed, makes a second comp and lay, and moves A's edge onto them. Pointing the originals back afterwards merges nothing.
Undo to A needs three kinds of write: old
template_taskper claimed Task, oldtask_template,DELETEper Task B made (its edges retire, probe 089). The apply removes B's edges between claimed Tasks.Undo to null gets no server help: delete B's edges between claimed Tasks yourself. Either way, write back the hand-edited fields read before the merge; the merge overwrote them and the undo's apply does too.
corpus/findings/096_task_template_unmerge.md
097_null_dates_unpin
A Task with no upstream never pins, on a null or a real date write; nulling its dates leaves its downstream unmoved, and pinned:false refills nothing.
| the Task | after a date write |
|---|---|
no edges, dates set null |
pinned stays false; a null write only pins a Task that has an upstream (093, entity_types/Task) |
| no edges, real dates | pinned stays false |
upstream-only (has downstream, no upstream), null or real dates |
pinned stays false |
its finish-to-start downstream |
unmoved by the null write; moved by the real one (03-11..03-12), as in 087 |
Only a Task with an upstream pins on a date write. Here neither a
nullnor a real date write setpinnedon a Task with no upstream, with or without a downstream. 087 and 093 measured the pin on dependents.PUT {"pinned": false}on a Task that was alreadyfalseis a no-op: the nulls survive it. No fallback anchor filled them: notduration, not a project date, not today.Sending the nulls and
pinned: falsein onePUTread back the same as the nulls alone.A
nullupstream leaves the downstream's stored dates where they were; the next real date write on the same upstream moves it again. The edge still schedules; anullgives it nothing to schedule from.A client that wants a Task to go back to "server picks the date" has no move here: clearing a root Task's dates is a dead end, not a pending state. It stays
null/nulluntil something writes a real date onto it.
corpus/findings/097_null_dates_unpin.md
098_template_merge_in_one_batch
Recipe 015's merge fits one _batch: requests run in order, so a task_template write sees claims made earlier in the batch, and null then T on the same Shot re-runs the apply.
A batch applies its requests in order and each sees the one before: a claim earlier in the batch stops the apply from duplicating that Task, exactly as when the claim is a call of its own.
Two updates of the same field on the same record in one batch are not collapsed.
nullthenTruns the apply, as two PUTs do (probe 084, Shot D);Talone on a Shot that holdsTdoes not.The one-batch merge and recipe 015's split sequence left the same Tasks, statuses and edges; the template's edge was written onto the claimed hand-made Task in both.
One call instead of three, and atomic: a failing claim rolls the clear and the set back with it (recipe 002), and a request failing after the set rolls back the apply's Tasks and edges (probe 113). Recipe 020 is this as code.
corpus/findings/098_template_merge_in_one_batch.md
099_template_apply_edge_copy_kept
A template apply copies a missing edge between two Tasks whose template_task already match it, whether either was claimed, kept, or created by that same call.
The edge is copied in all three cases: kept+claimed, kept+kept with the edge missing, and kept+created. Probe 092 already showed claimed+claimed, so every pairing of
{kept, claimed, created}a merge apply can produce ends up holding the template's edge.The copy comes from the
task_templatewrite, not from the claim. In case 1 the_batchclaim sety.template_taskand left the pair with no edge; the edge appeared only after the PUT.The apply fills edges between linked Tasks, not only the ones it just touched. Case 2 claimed and created nothing: both Tasks already had
template_taskset, yet the missing edge appeared.Clearing and re-setting
task_templateover Tasks linked by an earlier apply fills a missing edge (case 2), but the same write re-syncs those Tasks' fields to the template (probe 102). It is not a safe way to repair edges alone.
corpus/findings/099_template_apply_edge_copy_kept.md
100_duration_write_pin
Writing duration on a dependent Task does not pin it; a start_date write in the same run does. It keeps following the upstream, and a duration write upstream moves it.
| write | effect on the dependent (down) |
|---|---|
duration alone on an unlinked Task (solo) |
pinned stays false; start_date kept, due_date stretches to hold the new duration |
duration alone on down |
the same: pinned stays false, start_date kept (already the day after the upstream ends), due_date stretches |
| upstream moves later, after that | down moves with it, duration held at 1920 |
duration on the upstream (up) |
up's due_date moves; down and down2 follow it, same as a date write (087) |
start_date on down (control) |
pinned turns true; duration held, due_date moves; down2 follows |
durationdoes not pin. In the same run astart_datewrite ondowndid.due_datewas not written on the dependent here; that it pins too rests onentity_types/Task, 087 and 093.On the dependent, a
durationwrite keepsstart_dateand movesdue_date, the same as on the unlinkedsolo. The dependent then keeps following its upstream.down2moved on every write that moveddown, theduration-only write included: a dependent's owndurationwrite cascades downstream. It stayed put on the no-oppinned=falsewrite, where nothing moved.Writing
durationon the upstream end reschedules every unpinned downstream Task, so probe 087's date-based finding holds fordurationtoo.
corpus/findings/100_duration_write_pin.md
101_template_edge_conflict
On a claimed pair, a template apply replaces an existing edge of another type, or the reverse edge, with the template's edge: the old row is erased, not retired, and the PUT is a plain 200.
The template's edge wins. In both cases the pre-existing edge is gone and the template's
b on a finish-to-start-next-daystands in its place. No error, no skip, no duplicate, no loop.The old row is erased, not retired. It reads 404 under
options[return_only]=retired, where a TaskDependency the caller DELETEs reads 200. No retired row is left to find; read the edges first.Nothing rolls back: the PUT is 200,
task_templateis stored, and the unclaimed template taskcis generated. The caller learns of the swap only by reading the edges.An edge with a Task outside the template downstream of a claimed one (
x on a) is kept. The reverse, a claimed Task depending on an outside Task, is erased (probes 107, 109). An edge between two claimed Tasks that the template does not link either way is deleted (probe 102).
corpus/findings/101_template_edge_conflict.md
102_task_template_resync
Writing task_template T re-syncs every Task linked to T: T's non-empty values overwrite, status kept, dates and assignees kept or filled if empty; edges between linked Tasks reset to T's.
| on T's task | on the linked Task before | after the write |
|---|---|---|
a value in content, step, est_in_mins, sg_description, sg_sort_order, task_reviewers, milestone |
anything | overwritten with T's: a renamed Task gets its old name back |
| a value in a custom field: on the probed site one list field and one checkbox field, both behaved as above | anything | overwritten with T's |
duration |
a Task without dates | overwritten; a Task with start and due keeps its dates and the duration they give |
duration |
only start_date or only due_date set, duration null |
kept: stays null, no date filled (probe 108) |
a numeric 0: est_in_mins, or duration on a Task without dates |
a value | overwritten with 0 (probe 108) |
start_date, due_date |
set / empty | kept / filled, then moved by the dependency cascade (probe 087) |
task_assignees |
set / empty | kept / filled |
sg_status_list, pinned |
anything | kept |
empty: null, a checkbox's false, a text "" (stored as null on the template task) |
a value | kept: an empty template field never clears (probe 108) |
| edge, T has it | missing / other type or offset, offset_days null against 0 included (probe 105) |
created / erased and re-created as T's (new id) |
| edge T lacks | both ends linked to T | erased |
| edge T lacks | downstream end linked to T, upstream end not (unlinked, another template, another entity) | erased (probes 107, 109) |
| edge T lacks | upstream end linked to T, downstream end not | kept: x1 on a1, u2 on a2 here, w on b in probe 109 |
Every write that changes
task_templateto T re-syncs all Tasks already linked to T, after a clear or from another template, and Tasks claimed a moment earlier (recipe 015) the same as Tasks T made. Setting milestone collapses the Task to one day at its due date, duration 0.Kept dates are the re-sync's, not a pin's: the unpinned root a1 keeps them. The re-sync leaves
pinnedas it was. An edge it deletes is erased: 404 underoptions[return_only]=retired.Writing another template U or null touches no T-linked Task or edge (probe 096 agrees).
The edge rows for a Task not linked to T are corrected by probes 107 and 109: this run measured only the outside Task downstream (x1, u2), and first read "one end unlinked → kept" for both directions.
Two Tasks linked to one template task: only one is re-synced and wired, picked unpredictably (probe 106).
Corrected in probe 084 (it read "only adds", linked Tasks "skipped") and recipe 015 (it read "creates only what is missing" and "Only
template_taskis written"). Probe 083 holds.
corpus/findings/102_task_template_resync.md
103_batch_delete_revive
A delete inside _batch retires a Task or TaskDependency exactly as DELETE does: same retired read-back, and revive returns the same id, fields, edges and Version.sg_task.
A batch
deleteis a retire, not an erase. Every read-back matched the plainDELETE: the row lists underreturn_only: retiredby_searchand byGET options[return_only]=retired, andPOST /entity/<type>/<id>?revive=1answersdid_revive: true.The side effects of deleting a Task (probe 089) are the same on both routes: its edges retire with it, the neighbour's link drops,
Version.sg_taskreads null, and revive restores all of it with the same ids.An undo stack can record the ids a batch delete returns (
data[i].id) and revive them one by one; recipe 018 applies to a batch-deleted edge unchanged.Not measured: revive inside
_batch(it accepts onlycreate,update,delete, recipe 002), a Task and its edge deleted in the same batch, and a PublishedFile link.
The probe provisions every row it reads; no operator step. It runs each row through the batch delete
first and the DELETE control second, on the same row, with a full read-back between steps.
corpus/findings/103_batch_delete_revive.md
104_template_unmerge_in_one_batch
Recipe 019's undo fits one _batch with the same end state, if the batch skips edges its own task_template write removes: deleting one 404s and rolls back all. Undo to null deletes them.
One batch gives the split sequence's end state in both cases measured: no duplicate Task, the old
template_tasklinks, the old edges with their ids, the snapshot's fields, status kept.Requests run in order and the
task_templateA write runs its apply mid-batch (probe 098): it removes B's edge between the two claimed Tasks. A later DELETE of that edge 404s and rolls back the whole batch (recipe 002). Recipe 019's step 3 reads the edges after that write; a batch cannot.So read every id before the batch and leave out edges whose two ends go back to a template task of a non-null old template. Undo to null: the server removes nothing, keep the DELETE. Mixed ends: not measured.
A Task DELETE in the batch retires its edges, as a DELETE call does (probe 089): paint on lay went with paint in both. Provisioned by the probe; no operator step. Recipe 022 is this as code.
corpus/findings/104_template_unmerge_in_one_batch.md
105_offset_days_null_vs_zero
TaskDependency offset_days null and 0 are stored and compared as different: a template apply deletes an entity edge with null against a template 0 (or the reverse) and re-creates it with a new id.
Null and 0 are two stored values. A create with null or with the key omitted reads back null; a create with 0 reads back 0.
offset_days is 0does not match a null row, andis nulldoes not match a 0.The apply compares them as different. Template 0 against entity null, and template null against entity 0, both end with the entity edge deleted (GET 404) and re-created with the template's value and a new id, the same as a real difference (the
e1control, 2 against 0). The unchangedd1kept its id.To keep edge ids through a re-apply, write
offset_daysexactly as the template holds it, null or 0, never one for the other. Anything keyed on a TaskDependency id loses it otherwise (probe 101: the old row is erased, not retired).The POST response omits
offset_dayswhen it is null; read it with a GET or a_search.Provisioned by the probe; no operator step. Only
finish-to-start-next-daywas measured, and the dates of null against 0 are probe 085's, not measured again here.
corpus/findings/105_offset_days_null_vs_zero.md
106_template_task_linked_twice
With two Tasks linked to one template task, an apply re-syncs and wires only one of them, picked unpredictably (not by id, age or edges); the other is left as is. No error, nothing duplicated.
One Task per template task is re-synced and wired, the others are skipped. The skipped one keeps its content and fields, still points at X, and gets no edge. No second X is created; w and y are created only when nothing links to them. Every PUT is 200.
Which one wins is not predictable from the caller's side. Across 6 runs the pick flipped on identical setups: not the lowest id, not the oldest
created_at, not the first bycontent, and not the Task already holding T's edges (Shot4 run 4).When the other Task wins, the loser's edges, both of T's shape, are handled unevenly:
y on xbwas deleted,xb on wwas kept, and the winner got both. Measured once; the cause is not measured.Before an apply, leave at most one Task per template task linked: unlink or re-point the others (
template_tasknull), or the result depends on the server's pick. Recipe 015's key caveat can produce this state (probe 096 made it by hand).
corpus/findings/106_template_task_linked_twice.md
107_dependency_three_task_loop
A three-Task loop is a 400 on a direct create and inside _batch, which rolls back whole. A template apply deletes a claimed Task's upstream edge from a Task outside the template, loop or not.
The loop check follows the whole chain: closing a three-Task cycle is the same 400 as the two-Task case (probe 085). Inside
_batchit counts rows the same batch created earlier, and the batch rolls back with no row left (recipe 002).A template apply never closed the loop because it had already deleted a leg. The
PUT task_templateeraseda on x, where a claimed Task depends on a Task outside the template, in the control Shot too, where no loop was possible. No error; the row reads 404 underoptions[return_only]=retired, as in probe 101.The reverse,
x on b(the outside Task downstream of a claimed one), was kept, as probes 101 and 102 found. Probe 102's row "one end unlinked → kept" holds only for that direction. Read a claimed Task'supstream_tasksbefore the apply and re-create the edges it should keep.Not measured: a claimed Task that has an upstream in the template (here
b) depending on an outside Task, and a loop the apply could close without deleting a leg.
corpus/findings/107_dependency_three_task_loop.md
108_task_template_resync_empties
Re-sync to T: a numeric 0 on T's task overwrites (est, duration); milestone false and "" (stored null) keep the Task's value; a Task with only start or only due keeps its null duration.
| on T's task | on the linked Task | after the re-sync |
|---|---|---|
milestone true (control) |
false | overwritten: true |
milestone false |
true | kept: true. False is the checkbox's empty |
est_in_mins 0 |
60 | overwritten: 0 |
duration 0 |
1920, no dates | overwritten: 0 |
duration 480 (control) |
1920, no dates | overwritten: 480 (102 agrees) |
sg_description "" |
"hand" | kept. The server stored "" as null on T's task, so "" and null are one case |
sg_description null, est_in_mins null (negative control) |
a value | kept (102 agrees) |
duration 960 |
only start_date set, duration null |
kept: duration stays null, no date filled |
duration 960 |
only due_date set, duration null |
kept: duration stays null, no date filled |
0 is a value, false is not. A numeric 0 on T's task wipes the Task's number; a false checkbox never clears a true one. A merge that means "leave it" must not store 0 on the template.
durationcopies only onto a Task with no dates (here and in 102). Either date set, alone or with the other, keeps the Task's duration; with one date only, it stays null.A text field cannot hold "" on a template task: the write is accepted and reads back null.
Not measured: "" on the linked Task side;
sg_sort_order0; a custom number or checkbox field;milestonefalse on T vs a Task with dates; duration 0 on T vs a dated Task.
corpus/findings/108_task_template_resync_empties.md
109_template_apply_outside_edge
A template apply erases an edge where a linked Task depends on a Task not linked to the template (root or not, other template, other Shot); it kept the edge with the outside Task downstream.
Measured rule: an edge whose downstream end is a Task linked to T and whose upstream end is not linked to T is erased by the apply. It held for a root (a) and a non-root (b), for an unlinked Task, a Task linked to another template, and a Task on another entity. The claim alone did not touch it; the
PUT task_templatedid.An edge whose upstream end is linked to T and whose downstream end is not (w on b) was kept, as in probes 101, 102 and 107. One case only.
Erased, not retired: 404 under
options[return_only]=retired, where an edge the caller DELETEs reads 200 (control in this run; probe 101 too). No error, no row to recover. Read each linked Task'supstream_tasksbefore the apply and re-create the edges to keep.Probe 102's "one end unlinked or linked to another template → kept" holds only for the downstream direction.
Not measured: an outside Task upstream of a Task the apply creates (no edge to that Task can exist before the apply makes it); an outside Task downstream of a root; outside edges on a re-apply of the same template.
corpus/findings/109_template_apply_outside_edge.md
110_template_task_after_revive
Revive restores template_task. A task_template write while the Task is retired re-creates it, so a later revive leaves two Tasks on one template task. Revive first, then write.
Revive restores
template_task, on both delete routes. The retired row keeps it: a_searchwithreturn_only: retiredreadstemplate_taskA.x before the revive.A retired Task does not count as linked. The apply re-creates its template task (probe 084's match key) and copies the template edge onto the copy. Reviving the original afterwards gives two Tasks on A.x, and Y then depends on both, by two edges.
Order: revive, then the template write. Revived first, the Task is linked again and the apply makes nothing.
_batchtakes no revive (recipe 021), so an undo revives by separate calls before its batch (recipe 022).Measured with null -> A only. The B -> A write of an undo (probes 096, 104) was not measured here, nor a Task retired from a template other than the one written.
The probe provisions every row; no operator step. Y's Task is the negative control: live throughout, never duplicated in any of the four runs.
corpus/findings/110_template_task_after_revive.md
111_template_undo_outside_edge
An undo's write back to template A erases every edge whose downstream Task is A-linked and that A lacks, pre-merge edges included; recipe 022 DELETEs one such edge, 404s and rolls back.
The write back to A applies probe 109's rule: every edge whose downstream Task is A-linked and that A lacks is erased, whatever the upstream end: extra (R1, roto on x), merge-made (R2), or A-linked (roto on lay). Pre-merge edges the merge kept (roto on x, roto on lay) are lost by the undo. Edges with only the upstream end on A (paint on lay, y on lay) are kept.
Recipe 022 DELETEs every non-snapshot edge unless both ends go back to A, so a re-created outside edge (R1) 404s the batch and nothing lands. Leave out every edge whose downstream end goes back to an A task.
A's own roto on comp was re-created with a new id on both Shots; probe 104, where roto had no other upstream edge, kept the id. Recipe 019's step 3 sweep then deleted it, leaving W with no edge at all. Which hand edge causes the re-create: not measured.
Re-create the lost pre-merge edges from a snapshot of ends, type and offset (recipe 016). Doing that inside the undo batch: not measured.
corpus/findings/111_template_undo_outside_edge.md
112_template_unmerge_linked_twice
Undo relinking two Tasks to one template task: A wires either one (11 of 14 picked the loser), nothing is made. Relink the loser after the task_template write: then it matches the one-link undo.
Recipe 022 on this state does not undo. A's apply re-syncs and wires one of the two Tasks, the server's pick (probe 106): 11 of 14 went to the loser, the Task that held no edge and was unlinked by the merge, and the pick flipped between identical Shots in one run. Nothing is created.
When the loser is picked, the winner keeps B's fields and loses its edges: both of A's edges now sit on the loser, with new ids. Writing the snapshot's fields back does not move them. Recipe 022's
KEEPlackscontent, which A's re-sync renames on the loser: keep it.Relink only one Task per template task before the
task_templatewrite, the one that held the edges, and the others after it in the same batch: atemplate_taskwrite alone changes nothing (probe 096). D3 did so 3 of 3 and ended as the one-link control did.Even the control is not the pre-merge state to the id: B's apply erased
xa on w, a claimed Task on a Task outside B (probe 109), and A's apply recreates it with a new id. Every other id is kept.
corpus/findings/112_template_unmerge_linked_twice.md
113_batch_atomic_after_template_write
A _batch holding a task_template apply is atomic: a later or earlier failing request left no Task, no claim, no field write, no edge and no EventLogEntry row.
The apply rolls back with the batch. Wherever the failing request sits, a failed batch leaves no claim, no
task_templatechange, no generated Task or edge and no field write, and writes no EventLogEntry row. Recipe 002's rollback holds for server-side work.An EventLogEntry row showing an apply means a request that committed. A failed batch did not write it; look for a second call (recipe 020 is one batch; any after-apply step is another).
A
TaskDependencycreate naming a retired Task is 400Value is not legal.and takes the batch down. Re-read both ends before re-creating an edge.The script key is shared: filter the log on your own rows, as other writers land in the same window.
corpus/findings/113_batch_atomic_after_template_write.md
127_retry_and_client_uuid
A text field created with unique: true refuses a second create with the same value, case and outer spaces ignored, in a batch too. It is the only idempotency key: the API has no header for it. [partial]
not measured: whether unique spans projects, and whether a deleted row's value frees. One project only. Blocked on the work
A client read timeout says nothing about the server: the abandoned batch committed all 20 rows, readable under two seconds later (recipe 002 saw the same at 1001 rows). Look up before re-sending.
Create one text field with
unique: truefor the client UUID and send it on every create. The retry of a committed create then fails with code 104 instead of duplicating; treat that 400 as "already there" and read the row by the UUID.uniquecan only be set at create (probe 116).Uniqueness ignores case and surrounding spaces, so a UUID is safe but a human code is not a fit. The check runs inside
_batchas well, and a refusal rolls the whole batch back (recipe 002), including two rows of the same batch that collide with each other.The error title is the field's display name, not its programmatic name, and ends in a literal
<br>. Code 104 is the general create failure, so match on it plus the display name in the title.
corpus/findings/127_retry_and_client_uuid.md
136_unique_scope_retired
A deleted row frees its unique value: a new row may take it. Reviving the old row while another holds the value is a 400 code 104 PG transaction error, and the row stays retired. [partial]
not measured: uniqueness across two projects. Probes write only into the sandbox and a project entity refuses a row with no project. Blocked on the site: needs a second writable project
| row state | holds K for uniqueness |
|---|---|
| live | yes: a create with K is 400 code 104 |
| retired (deleted) | no: a create with K is 201, and the retired row still stores K |
| revived while a live row holds K | the revive fails, 400 code 104, row stays retired |
| revived while nothing holds K | 200; the row holds K again and blocks the next create |
A lookup by key must search live rows only (the default) and treat a retired match as absent. A client that undoes a delete by reviving must expect the revive to fail when the key was reused, and the error names a Postgres transaction, not uniqueness.
The duplicate refusal names the field's display name, not its
sg_name, and ends in<br>.Whether two projects can hold the same value is unmeasured. The refusal says "required to be unique" and names no scope; key on a value that is unique across the site (a UUID) and the question does not arise.
corpus/findings/136_unique_scope_retired.md
137_batch_create_coercion
A _batch create on a custom entity takes a numeric string in a float and honours created_at, as a single POST does. It also takes an Integer and "1e3", which a single POST refuses.
Send floats as strings in either path:
"1.5"is accepted by both and reads back as a string.created_atandupdated_atin a batch create are stored as sent, offsets normalised to UTC, as on a singlePOST(probe 070). Stamp capture time this way.The batch path is wider than the single one: an Integer and an exponent string both store. Code that is tested by batch can fail by single
POST, so validate before sending rather than relying on either (report 001).A refused batch value is code 104
Value is not legal.naming the field; the single path's code 103 says which types it takes. Debug a batch refusal by sending that request alone.
corpus/findings/137_batch_create_coercion.md
143_nonadmin_rows
On the probed site an Artist may not create, edit or delete custom-entity rows (status only) and may create but not delete an Attachment, its own included. The group rights call predicts each answer. [partial]
not measured: Manager and Vendor writes; rights read, not exercised. Blocked on the site: impersonation on for one of each in the sandbox, then 143 --write
Read the caller's own group with
GET /schema/permission_groupsthen.../entity_types/<Type>before writing: every Artist answer above matched the table, thesg_status_listexception included. A person sees only their own group; an Admin sees all.A refusal is a 400 code 104 naming the type or the field, as on Task and Shot (probe 094).
On the probed site a capture app run by an Artist cannot make its own rows on custom entities and cannot remove a photo it uploaded. Either the people get Manager, the site's Artist rules change, or the app writes through a script key.
Manager's rights were read, not exercised; a conditional rule can still refuse a write the table lists as allowed (probe 094).
corpus/findings/143_nonadmin_rows.md
145_time_fields
date_time rounds to the second on POST and PUT (.999 goes up, .5 stays) but truncates in a _batch create. A new timecode field has no rate property; it is integer ms rendered at the site's fixed rate.
date_timekeeps whole seconds and the path decides which second. Round to the second yourself before sending, then every path stores the same value. A.999capture time sent by_batchis one second earlier than the same value sent byPOST.The rounding is not half-up:
.5stayed on its second and.999went to the next. Where the cut lies between was not measured. A filter value is rounded the same way as a write, so filtering with the value that was sent finds the row.A timecode field has no rate anywhere: the create refuses a rate property, the schema shows none, and the value is milliseconds of wall-clock time.
01:00:00:12therefore means3600000 + 12 * 1000 / fpsms, rounded to an integer, and3600500and3600501both render as frame 12.Milliseconds are fine enough for frames (one frame at 23.976 is 41.7 ms), but the field stores no rate, so a reader cannot tell which rate a value was written at, and the server renders every value at its own fixed rate (
field_types/timecode). Store a frame count in anumberfield and the rate beside it, or theHH:MM:SS:FFstring intext, as the stock cut fields do.A new duration field behaves as the stock one: integer minutes, a float or numeric string truncated toward zero, a clock string refused.
corpus/findings/145_time_fields.md
146_note_unique_key
A unique: true text field works on Note as on Version (probe 127), and refuses a duplicate on PUT and under sudo too. A Note.meta key is found by contains, case-sensitive, and enforces nothing. [partial]
not measured: uniqueness across two projects. Probes write only into the sandbox. Blocked on the site: run 146 --write --second-project <name> with a second writable project
Note takes a unique field as Version and custom entities do; case, outer spaces and the
islookup behave as probe 127 measured. The refusal is the same code 104 undersudo_as_loginand on aPUT, so a person's retry fails the same way: treat it as "already there" and read the Note by the key.metais a working lookup with no admin step: seed{"onset_uuid": ...}in the create, find it withcontains. It does not stop a retry from making a second Note, so look up before every create, and send the key in the case it was minted in.contentand the other fields stay editable on a Note found bymeta; onlymetaitself is fixed.Whether two projects can hold the same key is unmeasured (probe 136 stopped at the same place). A UUID key makes the answer moot.
corpus/findings/146_note_unique_key.md
148_note_author_fields
user and created_by are both honoured on a Note or Version create, though the schema flags created_by read only; a PUT to it is 400. Under sudo_as_login all three author fields are the person. [partial]
not measured: a launcher session bearer (auth_type session_token). Needs a person: 052 --login, then 148 --write --session
created_byis writable once, on create, likecreated_at(probe 070) andNote.meta(field_types/jsonb). The schema'seditable: falsedescribes the update path only. Any caller can name another person as creator, socreated_byis not proof of who wrote a row.Under
sudo_as_loginthe person iscreated_by,updated_byanduserwith nothing sent. A script sendinguseralone still leaves itself increated_byandupdated_by.The launcher bearer's claim is
user: HumanUserwithauth_type: session_token(probe 052), unlike the sudo bearer, whoseuserstays the ApiUser. What it records here is unmeasured. Run052 --login, approve in the browser, then148 --write --session.
corpus/findings/148_note_author_fields.md
154_batch_multi_entity_mode
multi_entity_update_mode in a _batch update's data adds, removes and sets as on a PUT, and several updates of one record in one batch apply in request order, each row echoing the state after it.
Write the mode inside
dataexactly as in aPUTbody (recipe 009). A bare list still replaces the set, in a batch as on aPUT.Requests on one record run in order, each on the result of the one before:
addthensetends at theset,setthenaddkeeps both. Each result row is the whole record after that request (recipe 002), so the last row for a record is its final state.Several link edits to one row can share a batch with no read in between.
corpus/findings/154_batch_multi_entity_mode.md
156_action_menu_item
An ActionMenuItem creates from {} at 201 and url is not checked; an Artist is refused. Run from the web interface, an http url got a form POST in a new tab, json or not, with no token. [partial]
not measured: a custom-protocol url opening an app, whether permissions_groups hides an item in the web interface, and Manager rights. Each needs a person, steps below. Blocked on the work
Send
title,url,entity_typeandprojectsyourself: the server takes a row with none of them, and checks onlyentity_type(field_types/entity_type) and the list fields.Creating one is an administrator's call on the probed site: Admin 201, Artist 400 code 104. Manager was not reachable (probe 132), so do not infer it.
permissions_groupsis not a read filter: an Artist reads rows restricted to Admin. Whether it hides the item in the web interface is unmeasured.secret_tokenis write-only through the API; keep the value on the client that checks signatures.Parse the request as a form. With
payload_content_typejson, the browser posted the sameapplication/x-www-form-urlencodedbody to an httpurlas withform, field for field, in this run.Act on
selected_ids, split on commas.idsis every row on the page, selected or not, andtitleis the stringundefined.Check who sent it yourself. The body names a person (
user_id,user_login) and holds no token, key or password, so any client that can reach theurlcan post the same form. Whethersecret_tokenadds a signature was not measured.Accept a cross-site navigation:
Origin: null,Sec-Fetch-Site: cross-site, noReferer. A server that refuses cross-origin form posts refuses every run. Its response is the page the new tab shows.
Needs a person
| question | step |
|---|---|
a custom-protocol url opening an app |
156 --write --listen 8765 --hold 900 on the machine with the browser; sign in, right-click a Shot in the sandbox project, run zzprobe 156 protocol, which points at sgonset://shot/1 |
whether permissions_groups hides an item in the web interface |
the same run, signed in as an Artist: which of zzprobe 156 for admin, ... for artist and ... for everyone a Shot's menu lists |
| Manager rights | turn on can_impersonate_this_user for an active Manager, run 156 --write |
corpus/findings/156_action_menu_item.md
158_project_text_size
A custom text field on Project stored 1,000,000 characters of JSON byte for byte, \n, \r\n and tabs kept, with no refusal. Leading and trailing whitespace is stripped.
Write
JSON.stringify(value)and parse what reads back. A serializer that ends in a newline gets one character fewer back: compare parsed values, not strings or hashes.1,000,000 characters was a 200 in about a second. Nothing larger was sent, so a limit, if any, is above it.
GET /entity/projects/<id>with nofieldsreturns every field, a custom field of 1 MB included, while the listingGET /entity/projectswith nofieldsreturns ids only. Namefieldson every read of a Project with a large field, or every client on the site pays for it.
corpus/findings/158_project_text_size.md
159_project_field_update_rights
An Admin updates a custom field on a Project, member or not. An Artist in the project reads it and gets 400 code 104 The field is not editable for this user on a PUT; outside it, 404 on the read. [partial]
not measured: Manager and Vendor writes; rights read, not exercised. Blocked on the site: impersonation on for one of each, then 159 --write
Settings an Artist must read and an Admin writes fit a Project field: an Artist who is a member reads it with a plain
GET. An Artist cannot save them; route that write through an Admin or the script.Per caller
editableinGET /schema/Project/fields/<field>?project_id=predicted every answer (probe 094). Read it to grey out a settings screen before the PUT.Project membership gates an Artist's read: outside the project the Project is a 404, so a field on it cannot be read either.
The Manager row allows
update, but a rights table can still refuse what it lists (probe 094). Treat Manager as unknown until measured.
corpus/findings/159_project_field_update_rights.md
161_link_to_deleted_row
A link to a deleted row is hidden, not removed: it reads null or drops out, and returns on revive, even after a replace. A write naming a deleted row is 400 code 104 Value is not legal.
A replace does not drop a hidden link. On
Version.playlists, with P1 retired,[P2]answered 200 and read[P2]; reviving P1 brought it back.removenaming P1 is the same 400, so nothing measured removes it. Expect a revive to restore every link to the row. Not measured on an entity field.Before writing a link, drop every target the client holds that may have been deleted elsewhere: one retired id fails the whole update, the live ones with it.
Value is not legal.also answers a type the field does not take (field_types/multi_entity). To tell a deleted row from a wrong type, read the target withoptions[return_only]=retired.
corpus/findings/161_link_to_deleted_row.md
164_vendor_writes
On the probed site a Vendor creates no Bid or Bid Line, by POST or _batch, and updates only sg_status_list, each refusal 400 code 104. Both preflight reads predicted every answer.
A Vendor on the probed site cannot enter a bid: no row can be created and no amount written, on a row assigned to their own Group as on any other.
_batchis refused like a singlePOST; it skips validation (probe 137), not permission.The refusal is checked before anything is written and names the type or the field (probe 094). An app reads it in advance from either call above; both listed exactly the one field that took a write.
For vendors to enter their own lines, the site gives Vendor create on Bid Line and update on the amount, ideally conditional on the Bid's Group, in the web interface (probe 162). Otherwise the app writes through a script after checking who is asking, and the row's
created_byis the script.
corpus/findings/164_vendor_writes.md
166_vendor_award
On the probed site a Group added to Shot.sg_vendor_groups shows the Shot to its people on their next request; removing it hides it. sg_people grants as users does; other projects stay hidden.
Award with
{"multi_entity_update_mode": "add", "value": [<group>]}and withdraw withremove(recipe 009). A bare list replaces the field, and with it every other vendor's award.The rule is evaluated per request: a bearer minted before the change sees the new answer on its next call, both ways. There is no token to refresh and no delay to wait out.
sg_peoplecounts because the rule names it. On another site read the rule first (probe 162): one naming onlyusersignoressg_people, which is a site field, not a stock one.On the probed site "See entities in assigned Projects only" holds: a Group's Shots in a project the person is not assigned to stay hidden. Here both vendors'
HumanUser.projectsheld the sandbox alone; assign the vendor to the project before an award there can reach them.Vendor reads Groups (probe 162), so each vendor sees which other Groups hold a Shot they see.
corpus/findings/166_vendor_award.md
168_group_create_rights
On the probed site a Manager or Admin person creates, renames, re-members and retires any Group; Artist and Vendor get 400 code 104. The person's own group rights on Group predict each answer. [partial]
not measured: an App Session Launcher bearer (probe 052); it needs the person to approve at a browser. sudo_as_login applies the same permission set (probe 094)
Check before showing the control: read the person's own
permission_rule_set, itscode, thenactions.create.accesson Group. An Admin lists every group, so the listing alone does not name theirs.A refusal is 400 code 104, not 403, with no
sourceordetail. Probe 094's shape holds for Group.The right is per type, not per creator: a Manager renames, re-members and retires a Group someone else made, a vendor's included. An app that lets production create Groups lets it retire any Group.
codeis neither required nor unique, whatever the schema says. Search bycodebefore creating, and keep the id: two Groups may share a name. A retired Group drops out ofHumanUser.groups.A Group made by a person works in
Shot.sg_vendor_groupson the vendor's next request (probe 166).
corpus/findings/168_group_create_rights.md