@elytracms/forms 0.0.103 → 0.0.104

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@elytracms/forms",
   "author": "finaldream <hi@finaldream.de>",
-  "version": "0.0.103",
+  "version": "0.0.104",
   "engines": {
     "node": ">=22.18.0"
   },
@@ -28,13 +28,13 @@
   "dependencies": {
     "lucide-react": "^1.23.0",
     "zod": "^4.4.3",
-    "@elytracms/core": "^0.0.103"
+    "@elytracms/core": "^0.0.104"
   },
   "peerDependencies": {
     "convex": "^1.42.1",
     "react": "^19.0.0",
-    "@elytracms/next": "^0.0.103",
-    "@elytracms/studio": "^0.0.103"
+    "@elytracms/next": "^0.0.104",
+    "@elytracms/studio": "^0.0.104"
   },
   "peerDependenciesMeta": {
     "@elytracms/next": {
@@ -59,8 +59,8 @@
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "typescript": "^6.0.3",
-    "@elytracms/next": "^0.0.103",
-    "@elytracms/studio": "^0.0.103"
+    "@elytracms/next": "^0.0.104",
+    "@elytracms/studio": "^0.0.104"
   },
   "files": [
     "dist",

package/src/convex/dev-ingest-runner.convex.test.ts

@@ -195,21 +195,22 @@ describe('pnpm dev:ingest — every scenario against the real engine (convex-tes
     expect(await t.run(async (ctx) => (await ctx.db.system.query('_storage').collect()).length)).toBe(0)
   })
 
-  it('the EC-750 scenario: 11/11 — a sibling forged by forms:save with B’s files is removed, B keeps its bytes and binding (the close’s expected lines)', async () => {
+  it('the EC-750 scenario: 12/12 — a sibling forged by forms:save with B’s files is removed, B keeps its bytes and binding (the close’s expected lines)', async () => {
     const core = await runner()
     const t = await backend()
     const lines: string[] = []
     const scenario = core.INGEST_SCENARIOS.find((entry) => entry.name === 'ec750')!
     const result = await core.runIngestScenario(scenario, port(core, t), { say: (line) => lines.push(line), wire, runId: 'r', now: () => T0 })
-    expect(result).toEqual({ ok: true, passed: 11, failed: [] })
+    expect(result).toEqual({ ok: true, passed: 12, failed: [] })
     expect(lines).toEqual(
       expect.arrayContaining([
         '  ✓ B’s binding records B as its owner: true',
+        '  ✓ …and B’s kind: true', // EC-762: the owner is the record's kind AND id
         '  ✓ A, created by forms:save, lists B’s file: true',
         '  ✓ removing A keeps B’s bytes: true',
         '  ✓ …and B’s binding: true',
         '  ✓ removing B deletes B’s file: false',
-        '✓ ec750: 11/11 expectation(s) held',
+        '✓ ec750: 12/12 expectation(s) held',
       ]),
     )
     expect(await leftovers(t)).toEqual({ submissions: 0, bindings: 0, assets: 0 })

package/src/convex/index.ts

@@ -66,8 +66,8 @@ import type { FormDeliveryRequest } from '../shared/delivery'
  *   predictable file another intent stored can never be deleted through a rollback). The
  *   one deletion, `remove`, goes through the engine's `releaseIngestUploads`, which deletes
  *   only bytes a claim bound (EC-671) to THAT row (EC-750 — every binding records the row
- *   that claimed it): an id a visitor or an editor merely NAMES is never deleted, even
- *   another row's claimed file;
+ *   that claimed it, by its kind and id, EC-762): an id a visitor or an editor merely NAMES is
+ *   never deleted, even another row's claimed file;
  * - **`deliver`** — the scheduled action per row: it asks the site's delivery route to send
  *   (`attemptFormDelivery`) and `recordDelivery` logs the answer per recipient and schedules
  *   the next attempt (`applyDeliveryOutcome`);
@@ -139,10 +139,11 @@ export const save = mutation({
 
 /**
  * Delete a submission AND the files it claimed (no claimed bytes outlive their row). EC-671 /
- * EC-750: through `releaseIngestUploads`, asked for THIS row's id — it deletes only the files
- * this row's claim bound, read by owner, never the row's `files` column (an editor's write can
- * put any id there, another row's file included, or clear it) — and, EC-685, keeps a claimed
- * file an editor has since made an asset of (the asset owns it now).
+ * EC-750: through `releaseIngestUploads`, asked for THIS row — the submission kind and its id
+ * (EC-762) — it deletes only the files this row's claim bound, read by owner, never the row's
+ * `files` column (an editor's write can put any id there, another row's file included, or clear
+ * it) — and, EC-685, keeps a claimed file an editor has since made an asset of (the asset owns
+ * it now).
  */
 export const remove = mutation({
   args: { [kind.idKey]: v.string() },
@@ -150,7 +151,7 @@ export const remove = mutation({
     await requireCapability(ctx, kind.access.write)
     const doc = await findRecordDoc(ctx, kind, args[kind.idKey] as string)
     if (!doc) return
-    await releaseIngestUploads(ctx, doc.recordId)
+    await releaseIngestUploads(ctx, kind, doc.recordId)
     await ctx.db.delete(doc._id)
   },
 })
@@ -179,14 +180,14 @@ export const ingest = internalMutation({
     if (!read.ok) return { ok: false, status: read.status, message: read.message, issues: read.issues }
 
     // EC-578: the one id factory (UUID v4) — never a clock or a counter. EC-750: minted BEFORE
-    // the claim, which binds every file to this row (a refused claim leaves the id unused; a
-    // retried request re-mints).
+    // the claim, which binds every file to this row — its kind and this id, EC-762 (a refused
+    // claim leaves the id unused; a retried request re-mints).
     mintSubmissionUuid ??= createUuidIdFactory()
     const id = `${kind.idPrefix}_${mintSubmissionUuid()}`
     // EC-695: every upload claimed in ONE engine call, after every check above that can refuse —
     // all bound, or none (a refused claim refuses the submission, and nothing was bound, so
     // nothing is released: this handler never deletes bytes). Nothing after it refuses.
-    const claim = await claimIngestUploads(ctx, body.uploads ?? [], body.target, receivedAt, id)
+    const claim = await claimIngestUploads(ctx, body.uploads ?? [], body.target, receivedAt, kind, id)
     if (!claim.ok) return claim
     const files: SubmissionFile[] = []
     const namesUsed = new Map<string, number>()

package/src/convex/sibling-release.convex.test.ts

@@ -137,7 +137,10 @@ const bindings = (t: Backend) =>
   t.run(async (ctx) =>
     (await ctx.db.query('records').collect())
       .filter((record) => record.kind === 'ingestBinding')
-      .map((record) => ({ storageId: record.recordId, owner: (record.data as { owner?: string }).owner })),
+      .map((record) => {
+        const data = record.data as { ownerKind?: string; owner?: string }
+        return { storageId: record.recordId, ownerKind: data.ownerKind, owner: data.owner }
+      }),
   )
 const deleteBlob = makeFunctionReference<'mutation', { storageKey: string }, unknown>('assets:deleteBlob')
 
@@ -155,10 +158,11 @@ async function promote(t: Backend, assetId: string, storageKey: string) {
 }
 
 describe('EC-750 probe — removing a submission deletes only the files THAT submission claimed', () => {
-  it('a claim binds each file to the submission that claimed it (the owner, not the form)', async () => {
+  it('a claim binds each file to the submission that claimed it (the owner — its kind and id — not the form)', async () => {
     const t = await backend()
     const b = await genuineSubmission(t)
-    expect(await bindings(t)).toEqual([{ storageId: b.file, owner: b.id }]) // base: owner undefined (the form key only)
+    // EC-762: the owner is the record's kind AND id (a record is both).
+    expect(await bindings(t)).toEqual([{ storageId: b.file, ownerKind: 'submission', owner: b.id }]) // base: owner undefined (the form key only)
   })
 
   it('Codex’s trace: A is created by forms:save carrying B’s files; removing A keeps B’s bytes and B’s binding', async () => {
@@ -171,7 +175,7 @@ describe('EC-750 probe — removing a submission deletes only the files THAT sub
     expect(await row(t, 'submission_forged')).toBeUndefined()
     // Measured on the base (0b7bb049), counterexample form: both lines below read false / [].
     expect(await survives(t, b.file)).toBe(true) // base: false — A's removal deleted B's bytes
-    expect(await bindings(t)).toEqual([{ storageId: b.file, owner: b.id }]) // base: [] — B's binding stripped
+    expect(await bindings(t)).toEqual([{ storageId: b.file, ownerKind: 'submission', owner: b.id }]) // base: [] — B's binding stripped
     // B still holds its file: its row is intact, and its own removal deletes it (below).
     expect((await row(t, b.id))!.files!.map((file) => file.storageId)).toEqual([b.file])
   })
@@ -221,7 +225,34 @@ describe('EC-750 probe — removing a submission deletes only the files THAT sub
     await forgeSibling(t, 'submission_legacy', [{ field: 'cv', storageId: legacyFile, contentType: 'application/pdf', size: 300 }])
     await editor(t).remove(PROJECT_ID, 'submission_legacy')
     expect(await survives(t, legacyFile)).toBe(true) // base: false — any bound id the row named was deleted
-    expect(await bindings(t)).toEqual([{ storageId: legacyFile, owner: undefined }])
+    expect(await bindings(t)).toEqual([{ storageId: legacyFile, ownerKind: undefined, owner: undefined }])
+  })
+
+  it('EC-762: a KIND-LESS binding (its owner’s id alone, as EC-750 wrote it) is never deleted by its submission’s removal — residue, never loss', async () => {
+    const t = await backend()
+    const kindlessFile = await storeFile(t, 300, 'application/pdf')
+    const id = 'submission_kindless'
+    // The binding a claim wrote between EC-750 and EC-762: the owner's id in `key1`, no kind, no `key2`.
+    await t.run(async (ctx) => {
+      await ctx.db.insert('records', {
+        kind: 'ingestBinding',
+        recordId: kindlessFile,
+        data: { uploadId: 'upload_kindless', target: 'contact', owner: id, boundAt: T0 },
+        key1: id,
+        at: T0,
+        createdAt: T0,
+        updatedAt: T0,
+      })
+    })
+    await forgeSibling(t, id, [{ field: 'cv', storageId: kindlessFile, contentType: 'application/pdf', size: 300 }])
+    await editor(t).remove(PROJECT_ID, id)
+    expect(await row(t, id)).toBeUndefined()
+    // No owner-only fallback (it would re-open F51): the bytes stay, and the binding keeps holding them.
+    expect(await survives(t, kindlessFile)).toBe(true)
+    expect(await bindings(t)).toEqual([{ storageId: kindlessFile, ownerKind: undefined, owner: id }])
+    await promote(t, 'kindless-asset', kindlessFile)
+    expect(await asAdmin(t).mutation(deleteBlob, { storageKey: kindlessFile })).toEqual({ deleted: false, heldBy: 'ingest' })
+    expect(await survives(t, kindlessFile)).toBe(true)
   })
 
   it('assets:deleteBlob still keeps bytes a binding holds — after the forged A’s removal, B’s binding still protects f', async () => {