gip-remote 1.2.3 → 1.2.5

package/index.js

@@ -5,7 +5,7 @@ const z32 = require('z32')
 const def = require('./schema/hyperdb/index')
 const RemoteDrive = require('./lib/drive')
 const GitPearLink = require('./lib/link')
-const { parseCommit, walkTree } = require('./lib/git')
+const { parseCommit, parseTag, walkTree } = require('./lib/git')
 
 class Remote extends ReadyResource {
   _swarm = null
@@ -22,7 +22,7 @@ class Remote extends ReadyResource {
     let config
     if (typeof this._link === 'string') {
       this._name = this._link
-      config = {}
+      config = { core: store.get({ name: this._link }) }
     } else if (this._link.drive) {
       this._name = this._link.pathname?.split('/').slice(1)[0]
       config = { key: this._link.drive.key }
@@ -91,13 +91,18 @@ class Remote extends ReadyResource {
   }
 
   async getAllRefs() {
-    const branches = this._db.find('@gip/branches')
     const refs = []
 
+    const branches = this._db.find('@gip/branches')
     for await (const b of branches) {
       refs.push({ ref: `refs/heads/${b.name}`, oid: b.commitOid })
     }
 
+    const tags = this._db.find('@gip/tags')
+    for await (const t of tags) {
+      refs.push({ ref: `refs/tags/${t.name}`, oid: t.oid })
+    }
+
     const headBranch = await this.getHead()
     if (headBranch) {
       const head = refs.find((r) => r.ref === `refs/heads/${headBranch}`)
@@ -129,36 +134,87 @@ class Remote extends ReadyResource {
     return true
   }
 
-  // --- Push: store objects + index branch + files ---
+  async deleteTag(tagName) {
+    const tag = await this._db.get('@gip/tags', { name: tagName })
+    if (!tag) return false
+
+    await this._db.delete('@gip/tags', { name: tagName })
 
-  async push(branchName, commitOid, objects) {
+    // Remove file records for this tag
+    const filesBranch = 'tags/' + tagName
+    const files = this._db.find('@gip/files', { branch: filesBranch })
+    for await (const file of files) {
+      await this._db.delete('@gip/files', { branch: filesBranch, path: file.path })
+    }
+
+    await this._db.flush()
+    return true
+  }
+
+  // --- Push: store objects + index branch/tag + files ---
+
+  async push(refName, oid, objects) {
     // 1. Store all git objects
-    for (const [oid, obj] of objects) {
-      const existing = await this.getObject(oid)
+    for (const [objOid, obj] of objects) {
+      const existing = await this.getObject(objOid)
       if (existing) continue
 
       await this._db.insert('@gip/objects', {
-        oid,
+        oid: objOid,
         type: obj.type,
         size: obj.size,
         data: obj.data
       })
     }
 
-    // 2. Parse commit metadata
-    const commitObj = objects.get(commitOid)
-    if (!commitObj) throw new Error('Commit object not found: ' + commitOid)
+    // 2. Dereference tag objects to find the commit
+    let resolvedOid = oid
+    let obj = objects.get(resolvedOid)
+    if (!obj) throw new Error('Object not found: ' + resolvedOid)
+
+    let tagMeta = null
+    while (obj.type === 'tag') {
+      const tag = parseTag(obj.data)
+      if (!tagMeta) tagMeta = tag
+      if (!tag.object) throw new Error('Tag has no object: ' + resolvedOid)
+      resolvedOid = tag.object
+      obj = objects.get(resolvedOid)
+      if (!obj) throw new Error('Object not found: ' + resolvedOid)
+    }
 
-    const commit = parseCommit(commitObj.data)
-    if (!commit.tree) throw new Error('Commit has no tree: ' + commitOid)
+    if (obj.type !== 'commit') {
+      throw new Error('Expected commit, got ' + obj.type + ': ' + resolvedOid)
+    }
+
+    const commit = parseCommit(obj.data)
+    if (!commit.tree) throw new Error('Commit has no tree: ' + resolvedOid)
 
     // 3. Walk tree to enumerate files
     const files = walkTree(objects, commit.tree, '')
 
-    // 4. Insert file records
+    // 4a. Reconcile deletions — remove file records whose paths no longer
+    //     exist in the new tree. Without this, files removed in a commit
+    //     would persist in the index forever (only `deleteBranch` cleans
+    //     them up, and only on full branch deletion). The drive view would
+    //     keep showing ghost files; consumers iterating @gip/files would
+    //     emit stale entries.
+    //
+    //     We rebuild the new path set first, then sweep the existing
+    //     records — O(N) in the size of the indexed tree, same order as
+    //     the insert step that follows.
+    const newPaths = new Set(files.map((f) => f.path))
+    const existingFiles = this._db.find('@gip/files', { branch: refName })
+    for await (const file of existingFiles) {
+      if (!newPaths.has(file.path)) {
+        await this._db.delete('@gip/files', { branch: refName, path: file.path })
+      }
+    }
+
+    // 4b. Insert file records (idempotent w.r.t. (branch, path) — acts as
+    //     upsert for paths whose blob/mode/metadata changed).
     for (const file of files) {
       await this._db.insert('@gip/files', {
-        branch: branchName,
+        branch: refName,
         path: file.path,
         oid: file.oid,
         mode: file.mode,
@@ -169,21 +225,38 @@ class Remote extends ReadyResource {
       })
     }
 
-    // 5. Insert branch record
-    await this._db.insert('@gip/branches', {
-      name: branchName,
-      commitOid,
-      treeOid: commit.tree,
-      author: commit.author,
-      message: commit.message,
-      timestamp: commit.timestamp,
-      objects: [...objects.keys()]
-    })
+    const isTag = refName.startsWith('tags/')
+
+    if (isTag) {
+      // 5a. Insert tag record
+      const tagName = refName.slice(5) // strip 'tags/'
+      await this._db.insert('@gip/tags', {
+        name: tagName,
+        oid,
+        commitOid: resolvedOid,
+        treeOid: commit.tree,
+        tagger: tagMeta ? tagMeta.tagger : null,
+        message: tagMeta ? tagMeta.message : null,
+        timestamp: tagMeta ? tagMeta.timestamp : 0,
+        objects: [...objects.keys()]
+      })
+    } else {
+      // 5b. Insert branch record
+      await this._db.insert('@gip/branches', {
+        name: refName,
+        commitOid: oid,
+        treeOid: commit.tree,
+        author: commit.author,
+        message: commit.message,
+        timestamp: commit.timestamp,
+        objects: [...objects.keys()]
+      })
 
-    // 6. Set HEAD to first branch pushed (like git init)
-    const currentHead = await this.getHead()
-    if (!currentHead) {
-      await this._db.insert('@gip/head', { branch: branchName })
+      // 6. Set HEAD to first branch pushed (like git init)
+      const currentHead = await this.getHead()
+      if (!currentHead) {
+        await this._db.insert('@gip/head', { branch: refName })
+      }
     }
 
     // 7. Flush
@@ -192,29 +265,41 @@ class Remote extends ReadyResource {
 
   // --- Fetch support ---
 
-  async getRefObjects(commitOid, onLoad) {
-    const branches = this._db.find('@gip/branches')
-    let branch = null
+  async getRefObjects(oid, onLoad) {
+    let record = null
 
+    // Check branches first
+    const branches = this._db.find('@gip/branches')
     for await (const b of branches) {
-      if (b.commitOid === commitOid) {
-        branch = b
+      if (b.commitOid === oid) {
+        record = b
         break
       }
     }
 
-    if (!branch) return []
+    // Then check tags
+    if (!record) {
+      const tags = this._db.find('@gip/tags')
+      for await (const t of tags) {
+        if (t.oid === oid) {
+          record = t
+          break
+        }
+      }
+    }
+
+    if (!record) return []
 
     const results = []
-    for (const oid of branch.objects) {
-      const obj = await this.getObject(oid)
+    for (const objOid of record.objects) {
+      const obj = await this.getObject(objOid)
       if (!obj) continue
 
       // Empty blobs have null data after round-tripping through compact-encoding
       const data = obj.data || Buffer.alloc(0)
 
       if (onLoad) onLoad(obj.size)
-      results.push({ ...obj, data, id: oid })
+      results.push({ ...obj, data, id: objOid })
     }
 
     return results
@@ -223,8 +308,16 @@ class Remote extends ReadyResource {
   // --- Drive ---
 
   async toDrive(branch) {
+    // Check branches first, then tags
     const b = await this._db.get('@gip/branches', { name: branch })
-    if (!b) return null
+    if (!b) {
+      const t = await this._db.get('@gip/tags', { name: branch })
+      if (!t) return null
+      // For tags, files are stored under 'tags/<name>'
+      const drive = new RemoteDrive(this._db, { branch: 'tags/' + branch })
+      await drive.ready()
+      return drive
+    }
 
     const drive = new RemoteDrive(this._db, { branch })
     await drive.ready()

package/lib/git.js

@@ -35,6 +35,37 @@ function parseCommit(data) {
   return result
 }
 
+// --- Git tag parser ---
+
+function parseTag(data) {
+  const text = data.toString('utf8')
+  const lines = text.split('\n')
+  const result = { object: null, type: null, tag: null, tagger: null, timestamp: 0, message: '' }
+
+  let i = 0
+  for (; i < lines.length; i++) {
+    const line = lines[i]
+    if (line === '') {
+      i++
+      break
+    }
+
+    if (line.startsWith('object ')) result.object = line.slice(7)
+    else if (line.startsWith('type ')) result.type = line.slice(5)
+    else if (line.startsWith('tag ')) result.tag = line.slice(4)
+    else if (line.startsWith('tagger ')) {
+      const match = line.match(/^tagger (.+) <.+> (\d+) [+-]\d+$/)
+      if (match) {
+        result.tagger = match[1]
+        result.timestamp = parseInt(match[2])
+      }
+    }
+  }
+
+  result.message = lines.slice(i).join('\n').trim()
+  return result
+}
+
 // --- Tree walker: extracts all file paths from git tree objects ---
 
 function walkTree(objects, treeOid, prefix) {
@@ -136,4 +167,4 @@ async function toDisk(opts) {
   }
 }
 
-module.exports = { parseCommit, walkTree, toDisk }
+module.exports = { parseCommit, parseTag, walkTree, toDisk }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gip-remote",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Git+Pear remote DB for handling git data",
   "main": "index.js",
   "scripts": {

package/schema/hyperdb/db.json

@@ -1,5 +1,5 @@
 {
-  "version": 2,
+  "version": 3,
   "offset": 0,
   "schema": [
     {
@@ -77,6 +77,19 @@
       "derived": false,
       "key": [],
       "trigger": null
+    },
+    {
+      "name": "tags",
+      "namespace": "gip",
+      "id": 6,
+      "type": 1,
+      "version": 3,
+      "versionField": null,
+      "indexes": [],
+      "schema": "@gip/tags",
+      "derived": false,
+      "key": ["name"],
+      "trigger": null
     }
   ]
 }

package/schema/hyperdb/index.js

@@ -4,7 +4,7 @@
 const { IndexEncoder, c, b4a } = require('hyperdb/runtime')
 const { version, getEncoding, setVersion } = require('./messages.js')
 
-const versions = { schema: version, db: 2 }
+const versions = { schema: version, db: 3 }
 
 // '@gip/repos' collection key
 const collection0_key = new IndexEncoder([IndexEncoder.STRING], { prefix: 0 })
@@ -386,7 +386,72 @@ const collection5 = {
   decodedVersion: 0
 }
 
-const collections = [collection0, collection1, collection2, collection3, collection5]
+// '@gip/tags' collection key
+const collection6_key = new IndexEncoder([IndexEncoder.STRING], { prefix: 6 })
+
+function collection6_indexify(record) {
+  const a = record.name
+  return a === undefined ? [] : [a]
+}
+
+// '@gip/tags' value encoding
+const collection6_enc = getEncoding('@gip/tags/hyperdb#6')
+
+// '@gip/tags' reconstruction function
+function collection6_reconstruct(schemaVersion, keyBuf, valueBuf) {
+  const key = collection6_key.decode(keyBuf)
+  setVersion(schemaVersion)
+  const state = { start: 0, end: valueBuf.byteLength, buffer: valueBuf }
+  const type = c.uint.decode(state)
+  if (type !== 0) throw new Error('Unknown collection type: ' + type)
+  collection6.decodedVersion = c.uint.decode(state)
+  const record = collection6_enc.decode(state)
+  record.name = key[0]
+  return record
+}
+// '@gip/tags' key reconstruction function
+function collection6_reconstruct_key(keyBuf) {
+  const key = collection6_key.decode(keyBuf)
+  return {
+    name: key[0]
+  }
+}
+
+// '@gip/tags'
+const collection6 = {
+  name: '@gip/tags',
+  id: 6,
+  version: 3,
+  encodeKey(record) {
+    const key = [record.name]
+    return collection6_key.encode(key)
+  },
+  encodeKeyRange({ gt, lt, gte, lte } = {}) {
+    return collection6_key.encodeRange({
+      gt: gt ? collection6_indexify(gt) : null,
+      lt: lt ? collection6_indexify(lt) : null,
+      gte: gte ? collection6_indexify(gte) : null,
+      lte: lte ? collection6_indexify(lte) : null
+    })
+  },
+  encodeValue(schemaVersion, collectionVersion, record) {
+    setVersion(schemaVersion)
+    const state = { start: 0, end: 2, buffer: null }
+    collection6_enc.preencode(state, record)
+    state.buffer = b4a.allocUnsafe(state.end)
+    state.buffer[state.start++] = 0
+    state.buffer[state.start++] = collectionVersion
+    collection6_enc.encode(state, record)
+    return state.buffer
+  },
+  trigger: null,
+  reconstruct: collection6_reconstruct,
+  reconstructKey: collection6_reconstruct_key,
+  indexes: [],
+  decodedVersion: 0
+}
+
+const collections = [collection0, collection1, collection2, collection3, collection5, collection6]
 
 const indexes = [index4]
 
@@ -404,6 +469,8 @@ function resolveCollection(name) {
       return collection3
     case '@gip/head':
       return collection5
+    case '@gip/tags':
+      return collection6
     default:
       return null
   }

package/schema/hyperdb/messages.js

@@ -1,12 +1,12 @@
 // This file is autogenerated by the hyperschema compiler
-// Schema Version: 2
+// Schema Version: 3
 /* eslint-disable camelcase */
 /* eslint-disable quotes */
 /* eslint-disable space-before-function-paren */
 
 const { c } = require('hyperschema/runtime')
 
-const VERSION = 2
+const VERSION = 3
 
 // eslint-disable-next-line no-unused-vars
 let version = VERSION
@@ -234,8 +234,63 @@ const encoding5 = {
   }
 }
 
-// @gip/repos/hyperdb#0
+// @gip/tags.objects
+const encoding6_7 = encoding1_6
+
+// @gip/tags
 const encoding6 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.name)
+    c.string.preencode(state, m.oid)
+    c.string.preencode(state, m.commitOid)
+    c.string.preencode(state, m.treeOid)
+    state.end++ // flags are fixed size
+
+    if (version >= 3 && m.tagger) c.string.preencode(state, m.tagger)
+    if (version >= 3 && m.message) c.string.preencode(state, m.message)
+    if (version >= 3 && m.timestamp) c.uint.preencode(state, m.timestamp)
+    if (version >= 3 && m.objects) encoding6_7.preencode(state, m.objects)
+  },
+  encode(state, m) {
+    const flags =
+      (version >= 3 && m.tagger ? 1 : 0) |
+      (version >= 3 && m.message ? 2 : 0) |
+      (version >= 3 && m.timestamp ? 4 : 0) |
+      (version >= 3 && m.objects ? 8 : 0)
+
+    c.string.encode(state, m.name)
+    c.string.encode(state, m.oid)
+    c.string.encode(state, m.commitOid)
+    c.string.encode(state, m.treeOid)
+    c.uint8.encode(state, flags)
+
+    if (version >= 3 && m.tagger) c.string.encode(state, m.tagger)
+    if (version >= 3 && m.message) c.string.encode(state, m.message)
+    if (version >= 3 && m.timestamp) c.uint.encode(state, m.timestamp)
+    if (version >= 3 && m.objects) encoding6_7.encode(state, m.objects)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const r1 = c.string.decode(state)
+    const r2 = c.string.decode(state)
+    const r3 = c.string.decode(state)
+    const flags = c.uint8.decode(state)
+
+    return {
+      name: r0,
+      oid: r1,
+      commitOid: r2,
+      treeOid: r3,
+      tagger: version >= 3 && (flags & 1) !== 0 ? c.string.decode(state) : null,
+      message: version >= 3 && (flags & 2) !== 0 ? c.string.decode(state) : null,
+      timestamp: version >= 3 && (flags & 4) !== 0 ? c.uint.decode(state) : 0,
+      objects: version >= 3 && (flags & 8) !== 0 ? encoding6_7.decode(state) : null
+    }
+  }
+}
+
+// @gip/repos/hyperdb#0
+const encoding7 = {
   preencode(state, m) {
     c.buffer.preencode(state, m.key)
     state.end++ // flags are fixed size
@@ -266,10 +321,10 @@ const encoding6 = {
 }
 
 // @gip/branches/hyperdb#1.objects
-const encoding7_6 = encoding1_6
+const encoding8_6 = encoding1_6
 
 // @gip/branches/hyperdb#1
-const encoding7 = {
+const encoding8 = {
   preencode(state, m) {
     c.string.preencode(state, m.commitOid)
     c.string.preencode(state, m.treeOid)
@@ -278,7 +333,7 @@ const encoding7 = {
     if (m.author) c.string.preencode(state, m.author)
     if (m.message) c.string.preencode(state, m.message)
     if (m.timestamp) c.uint.preencode(state, m.timestamp)
-    if (m.objects) encoding7_6.preencode(state, m.objects)
+    if (m.objects) encoding8_6.preencode(state, m.objects)
   },
   encode(state, m) {
     const flags =
@@ -291,7 +346,7 @@ const encoding7 = {
     if (m.author) c.string.encode(state, m.author)
     if (m.message) c.string.encode(state, m.message)
     if (m.timestamp) c.uint.encode(state, m.timestamp)
-    if (m.objects) encoding7_6.encode(state, m.objects)
+    if (m.objects) encoding8_6.encode(state, m.objects)
   },
   decode(state) {
     const r1 = c.string.decode(state)
@@ -305,13 +360,13 @@ const encoding7 = {
       author: (flags & 1) !== 0 ? c.string.decode(state) : null,
       message: (flags & 2) !== 0 ? c.string.decode(state) : null,
       timestamp: (flags & 4) !== 0 ? c.uint.decode(state) : 0,
-      objects: (flags & 8) !== 0 ? encoding7_6.decode(state) : null
+      objects: (flags & 8) !== 0 ? encoding8_6.decode(state) : null
     }
   }
 }
 
 // @gip/files/hyperdb#2
-const encoding8 = {
+const encoding9 = {
   preencode(state, m) {
     c.string.preencode(state, m.oid)
     c.string.preencode(state, m.mode)
@@ -354,7 +409,7 @@ const encoding8 = {
 }
 
 // @gip/objects/hyperdb#3
-const encoding9 = {
+const encoding10 = {
   preencode(state, m) {
     encoding3.preencode(state, m.type)
     c.uint.preencode(state, m.size)
@@ -379,6 +434,58 @@ const encoding9 = {
   }
 }
 
+// @gip/tags/hyperdb#6.objects
+const encoding11_7 = encoding1_6
+
+// @gip/tags/hyperdb#6
+const encoding11 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.oid)
+    c.string.preencode(state, m.commitOid)
+    c.string.preencode(state, m.treeOid)
+    state.end++ // flags are fixed size
+
+    if (version >= 3 && m.tagger) c.string.preencode(state, m.tagger)
+    if (version >= 3 && m.message) c.string.preencode(state, m.message)
+    if (version >= 3 && m.timestamp) c.uint.preencode(state, m.timestamp)
+    if (version >= 3 && m.objects) encoding11_7.preencode(state, m.objects)
+  },
+  encode(state, m) {
+    const flags =
+      (version >= 3 && m.tagger ? 1 : 0) |
+      (version >= 3 && m.message ? 2 : 0) |
+      (version >= 3 && m.timestamp ? 4 : 0) |
+      (version >= 3 && m.objects ? 8 : 0)
+
+    c.string.encode(state, m.oid)
+    c.string.encode(state, m.commitOid)
+    c.string.encode(state, m.treeOid)
+    c.uint8.encode(state, flags)
+
+    if (version >= 3 && m.tagger) c.string.encode(state, m.tagger)
+    if (version >= 3 && m.message) c.string.encode(state, m.message)
+    if (version >= 3 && m.timestamp) c.uint.encode(state, m.timestamp)
+    if (version >= 3 && m.objects) encoding11_7.encode(state, m.objects)
+  },
+  decode(state) {
+    const r1 = c.string.decode(state)
+    const r2 = c.string.decode(state)
+    const r3 = c.string.decode(state)
+    const flags = c.uint8.decode(state)
+
+    return {
+      name: null,
+      oid: r1,
+      commitOid: r2,
+      treeOid: r3,
+      tagger: version >= 3 && (flags & 1) !== 0 ? c.string.decode(state) : null,
+      message: version >= 3 && (flags & 2) !== 0 ? c.string.decode(state) : null,
+      timestamp: version >= 3 && (flags & 4) !== 0 ? c.uint.decode(state) : 0,
+      objects: version >= 3 && (flags & 8) !== 0 ? encoding11_7.decode(state) : null
+    }
+  }
+}
+
 function setVersion(v) {
   version = v
 }
@@ -416,14 +523,18 @@ function getEncoding(name) {
       return encoding4
     case '@gip/head':
       return encoding5
-    case '@gip/repos/hyperdb#0':
+    case '@gip/tags':
       return encoding6
-    case '@gip/branches/hyperdb#1':
+    case '@gip/repos/hyperdb#0':
       return encoding7
-    case '@gip/files/hyperdb#2':
+    case '@gip/branches/hyperdb#1':
       return encoding8
-    case '@gip/objects/hyperdb#3':
+    case '@gip/files/hyperdb#2':
       return encoding9
+    case '@gip/objects/hyperdb#3':
+      return encoding10
+    case '@gip/tags/hyperdb#6':
+      return encoding11
     default:
       throw new Error('Encoder not found ' + name)
   }

package/schema/hyperschema/index.js

@@ -1,12 +1,12 @@
 // This file is autogenerated by the hyperschema compiler
-// Schema Version: 2
+// Schema Version: 3
 /* eslint-disable camelcase */
 /* eslint-disable quotes */
 /* eslint-disable space-before-function-paren */
 
 const { c } = require('hyperschema/runtime')
 
-const VERSION = 2
+const VERSION = 3
 
 // eslint-disable-next-line no-unused-vars
 let version = VERSION
@@ -234,6 +234,61 @@ const encoding5 = {
   }
 }
 
+// @gip/tags.objects
+const encoding6_7 = encoding1_6
+
+// @gip/tags
+const encoding6 = {
+  preencode(state, m) {
+    c.string.preencode(state, m.name)
+    c.string.preencode(state, m.oid)
+    c.string.preencode(state, m.commitOid)
+    c.string.preencode(state, m.treeOid)
+    state.end++ // flags are fixed size
+
+    if (version >= 3 && m.tagger) c.string.preencode(state, m.tagger)
+    if (version >= 3 && m.message) c.string.preencode(state, m.message)
+    if (version >= 3 && m.timestamp) c.uint.preencode(state, m.timestamp)
+    if (version >= 3 && m.objects) encoding6_7.preencode(state, m.objects)
+  },
+  encode(state, m) {
+    const flags =
+      (version >= 3 && m.tagger ? 1 : 0) |
+      (version >= 3 && m.message ? 2 : 0) |
+      (version >= 3 && m.timestamp ? 4 : 0) |
+      (version >= 3 && m.objects ? 8 : 0)
+
+    c.string.encode(state, m.name)
+    c.string.encode(state, m.oid)
+    c.string.encode(state, m.commitOid)
+    c.string.encode(state, m.treeOid)
+    c.uint8.encode(state, flags)
+
+    if (version >= 3 && m.tagger) c.string.encode(state, m.tagger)
+    if (version >= 3 && m.message) c.string.encode(state, m.message)
+    if (version >= 3 && m.timestamp) c.uint.encode(state, m.timestamp)
+    if (version >= 3 && m.objects) encoding6_7.encode(state, m.objects)
+  },
+  decode(state) {
+    const r0 = c.string.decode(state)
+    const r1 = c.string.decode(state)
+    const r2 = c.string.decode(state)
+    const r3 = c.string.decode(state)
+    const flags = c.uint8.decode(state)
+
+    return {
+      name: r0,
+      oid: r1,
+      commitOid: r2,
+      treeOid: r3,
+      tagger: version >= 3 && (flags & 1) !== 0 ? c.string.decode(state) : null,
+      message: version >= 3 && (flags & 2) !== 0 ? c.string.decode(state) : null,
+      timestamp: version >= 3 && (flags & 4) !== 0 ? c.uint.decode(state) : 0,
+      objects: version >= 3 && (flags & 8) !== 0 ? encoding6_7.decode(state) : null
+    }
+  }
+}
+
 function setVersion(v) {
   version = v
 }
@@ -271,6 +326,8 @@ function getEncoding(name) {
       return encoding4
     case '@gip/head':
       return encoding5
+    case '@gip/tags':
+      return encoding6
     default:
       throw new Error('Encoder not found ' + name)
   }

package/schema/hyperschema/schema.json

@@ -1,5 +1,5 @@
 {
-  "version": 2,
+  "version": 3,
   "schema": [
     {
       "name": "repos",
@@ -208,6 +208,62 @@
           "version": 2
         }
       ]
+    },
+    {
+      "name": "tags",
+      "namespace": "gip",
+      "compact": true,
+      "flagsPosition": 4,
+      "fields": [
+        {
+          "name": "name",
+          "required": true,
+          "type": "string",
+          "version": 3
+        },
+        {
+          "name": "oid",
+          "required": true,
+          "type": "string",
+          "version": 3
+        },
+        {
+          "name": "commitOid",
+          "required": true,
+          "type": "string",
+          "version": 3
+        },
+        {
+          "name": "treeOid",
+          "required": true,
+          "type": "string",
+          "version": 3
+        },
+        {
+          "name": "tagger",
+          "required": false,
+          "type": "string",
+          "version": 3
+        },
+        {
+          "name": "message",
+          "required": false,
+          "type": "string",
+          "version": 3
+        },
+        {
+          "name": "timestamp",
+          "required": false,
+          "type": "uint",
+          "version": 3
+        },
+        {
+          "name": "objects",
+          "array": true,
+          "type": "string",
+          "version": 3
+        }
+      ]
     }
   ]
 }