refactor: extract dev.hatk lexicons from cli.ts to JSON files

Move all 14 inlined dev.hatk.* lexicon definitions from cli.ts into
src/lexicons/dev/hatk/*.json. The hatk new command now copies them
with cpSync instead of writing each one inline. Build step copies
lexicons to dist/ alongside templates.

Co-Authored-By: Claude Opus 4.6 <[e-mail]>

packages/hatk/package.json

···
     "./renderer": "./dist/renderer.js"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && cp -r src/templates dist/templates",
+    "build": "tsc -p tsconfig.build.json && cp -r src/templates dist/templates && cp -r src/lexicons dist/lexicons",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {

packages/hatk/src/cli.ts

···
 #!/usr/bin/env node
-import { mkdirSync, writeFileSync, existsSync, unlinkSync, readdirSync, readFileSync } from 'node:fs'
+import { mkdirSync, writeFileSync, existsSync, unlinkSync, readdirSync, readFileSync, cpSync } from 'node:fs'
 import { resolve, join, dirname } from 'node:path'
 import { execSync, spawn } from 'node:child_process'
 import { loadLexicons, discoverCollections, buildSchemas } from './database/schema.ts'
···
 `,
   )
 
-  // Scaffold core framework lexicons under dev.hatk namespace
+  // Copy core framework lexicons under dev.hatk namespace
   const coreLexDir = join(dir, 'lexicons', 'dev', 'hatk')
   mkdirSync(coreLexDir, { recursive: true })
-
-  writeFileSync(
-    join(coreLexDir, 'describeCollections.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.describeCollections',
-        defs: {
-          main: {
-            type: 'query',
-            description: 'List indexed collections and their schemas.',
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                properties: {
-                  collections: {
-                    type: 'array',
-                    items: {
-                      type: 'object',
-                      required: ['collection'],
-                      properties: {
-                        collection: { type: 'string' },
-                        columns: {
-                          type: 'array',
-                          items: {
-                            type: 'object',
-                            required: ['name', 'originalName', 'type', 'required'],
-                            properties: {
-                              name: { type: 'string' },
-                              originalName: { type: 'string' },
-                              type: { type: 'string' },
-                              required: { type: 'boolean' },
-                            },
-                          },
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'describeFeeds.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.describeFeeds',
-        defs: {
-          main: {
-            type: 'query',
-            description: 'List available feeds.',
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                properties: {
-                  feeds: {
-                    type: 'array',
-                    items: {
-                      type: 'object',
-                      required: ['name', 'label'],
-                      properties: {
-                        name: { type: 'string' },
-                        label: { type: 'string' },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'describeLabels.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.describeLabels',
-        defs: {
-          main: {
-            type: 'query',
-            description: 'List available label definitions.',
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                properties: {
-                  definitions: {
-                    type: 'array',
-                    items: {
-                      type: 'object',
-                      required: ['identifier', 'severity', 'blurs', 'defaultSetting'],
-                      properties: {
-                        identifier: { type: 'string' },
-                        severity: { type: 'string' },
-                        blurs: { type: 'string' },
-                        defaultSetting: { type: 'string' },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'createRecord.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.createRecord',
-        defs: {
-          main: {
-            type: 'procedure',
-            description: "Create a record via the user's PDS.",
-            input: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['collection', 'repo', 'record'],
-                properties: {
-                  collection: { type: 'string' },
-                  repo: { type: 'string', format: 'did' },
-                  record: { type: 'unknown' },
-                },
-              },
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                properties: {
-                  uri: { type: 'string', format: 'at-uri' },
-                  cid: { type: 'string', format: 'cid' },
-                  commit: {
-                    type: 'object',
-                    properties: {
-                      cid: { type: 'string', format: 'cid' },
-                      rev: { type: 'string' },
-                    },
-                  },
-                  validationStatus: { type: 'string' },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'deleteRecord.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.deleteRecord',
-        defs: {
-          main: {
-            type: 'procedure',
-            description: "Delete a record via the user's PDS.",
-            input: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['collection', 'rkey'],
-                properties: {
-                  collection: { type: 'string' },
-                  rkey: { type: 'string' },
-                },
-              },
-            },
-            output: { encoding: 'application/json', schema: { type: 'object', properties: {} } },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'putRecord.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.putRecord',
-        defs: {
-          main: {
-            type: 'procedure',
-            description: "Create or update a record via the user's PDS.",
-            input: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['collection', 'rkey', 'record'],
-                properties: {
-                  collection: { type: 'string' },
-                  rkey: { type: 'string' },
-                  record: { type: 'unknown' },
-                  repo: { type: 'string', format: 'did' },
-                },
-              },
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                properties: {
-                  uri: { type: 'string', format: 'at-uri' },
-                  cid: { type: 'string', format: 'cid' },
-                  commit: {
-                    type: 'object',
-                    properties: {
-                      cid: { type: 'string', format: 'cid' },
-                      rev: { type: 'string' },
-                    },
-                  },
-                  validationStatus: { type: 'string' },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'uploadBlob.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.uploadBlob',
-        defs: {
-          main: {
-            type: 'procedure',
-            description: "Upload a blob via the user's PDS.",
-            input: {
-              encoding: '*/*',
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['blob'],
-                properties: {
-                  blob: { type: 'blob' },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'getPreferences.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.getPreferences',
-        defs: {
-          main: {
-            type: 'query',
-            description: 'Get all preferences for the authenticated user.',
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                properties: {
-                  preferences: { type: 'unknown' },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'putPreference.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.putPreference',
-        defs: {
-          main: {
-            type: 'procedure',
-            description: 'Set a single preference by key.',
-            input: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['key', 'value'],
-                properties: {
-                  key: { type: 'string' },
-                  value: { type: 'unknown' },
-                },
-              },
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                properties: {},
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'getFeed.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.getFeed',
-        defs: {
-          main: {
-            type: 'query',
-            description: 'Retrieve a named feed of items.',
-            parameters: {
-              type: 'params',
-              required: ['feed'],
-              properties: {
-                feed: { type: 'string', description: 'Feed name' },
-                limit: { type: 'integer', minimum: 1, maximum: 100, default: 30 },
-                cursor: { type: 'string' },
-              },
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['items'],
-                properties: {
-                  items: { type: 'array', items: { type: 'unknown' } },
-                  cursor: { type: 'string' },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'getRecord.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.getRecord',
-        defs: {
-          main: {
-            type: 'query',
-            description: 'Fetch a single record by AT URI.',
-            parameters: {
-              type: 'params',
-              required: ['uri'],
-              properties: {
-                uri: { type: 'string', format: 'at-uri' },
-              },
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                properties: {
-                  record: { type: 'unknown' },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'getRecords.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.getRecords',
-        defs: {
-          main: {
-            type: 'query',
-            description: 'List records from a collection with optional filters.',
-            parameters: {
-              type: 'params',
-              required: ['collection'],
-              properties: {
-                collection: { type: 'string' },
-                limit: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
-                cursor: { type: 'string' },
-                sort: { type: 'string' },
-                order: { type: 'string' },
-              },
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['items'],
-                properties: {
-                  items: { type: 'array', items: { type: 'unknown' } },
-                  cursor: { type: 'string' },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'searchRecords.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.searchRecords',
-        defs: {
-          main: {
-            type: 'query',
-            description: 'Full-text search across a collection.',
-            parameters: {
-              type: 'params',
-              required: ['collection', 'q'],
-              properties: {
-                collection: { type: 'string' },
-                q: { type: 'string', description: 'Search query' },
-                limit: { type: 'integer', minimum: 1, maximum: 100, default: 20 },
-                cursor: { type: 'string' },
-                fuzzy: { type: 'boolean', default: true },
-              },
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['items'],
-                properties: {
-                  items: { type: 'array', items: { type: 'unknown' } },
-                  cursor: { type: 'string' },
-                },
-              },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
-
-  writeFileSync(
-    join(coreLexDir, 'createReport.json'),
-    JSON.stringify(
-      {
-        lexicon: 1,
-        id: 'dev.hatk.createReport',
-        defs: {
-          main: {
-            type: 'procedure',
-            description: 'Report an account or record for moderation review.',
-            input: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['subject', 'label'],
-                properties: {
-                  subject: {
-                    type: 'union',
-                    description: 'The account or record being reported.',
-                    refs: ['#repoRef', '#strongRef'],
-                  },
-                  label: { type: 'string', description: 'Label identifier for the report reason.' },
-                  reason: { type: 'string', maxLength: 2000, description: 'Optional free-text explanation.' },
-                },
-              },
-            },
-            output: {
-              encoding: 'application/json',
-              schema: {
-                type: 'object',
-                required: ['id', 'subject', 'label', 'reportedBy', 'createdAt'],
-                properties: {
-                  id: { type: 'integer' },
-                  subject: { type: 'unknown' },
-                  label: { type: 'string' },
-                  reason: { type: 'string' },
-                  reportedBy: { type: 'string', format: 'did' },
-                  createdAt: { type: 'string', format: 'datetime' },
-                },
-              },
-            },
-          },
-          repoRef: {
-            type: 'object',
-            required: ['did'],
-            properties: {
-              did: { type: 'string', format: 'did' },
-            },
-          },
-          strongRef: {
-            type: 'object',
-            required: ['uri', 'cid'],
-            properties: {
-              uri: { type: 'string', format: 'at-uri' },
-              cid: { type: 'string', format: 'cid' },
-            },
-          },
-        },
-      },
-      null,
-      2,
-    ) + '\n',
-  )
+  const builtinLexDir = join(import.meta.dirname!, 'lexicons', 'dev', 'hatk')
+  cpSync(builtinLexDir, coreLexDir, { recursive: true })
 
   writeFileSync(
     join(dir, 'seeds', 'seed.ts'),

packages/hatk/src/lexicons/dev/hatk/createRecord.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.createRecord",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a record via the user's PDS.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["collection", "repo", "record"],
+          "properties": {
+            "collection": { "type": "string" },
+            "repo": { "type": "string", "format": "did" },
+            "record": { "type": "unknown" }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "uri": { "type": "string", "format": "at-uri" },
+            "cid": { "type": "string", "format": "cid" },
+            "commit": {
+              "type": "object",
+              "properties": {
+                "cid": { "type": "string", "format": "cid" },
+                "rev": { "type": "string" }
+              }
+            },
+            "validationStatus": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/createReport.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.createReport",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Report an account or record for moderation review.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["subject", "label"],
+          "properties": {
+            "subject": {
+              "type": "union",
+              "description": "The account or record being reported.",
+              "refs": ["#repoRef", "#strongRef"]
+            },
+            "label": { "type": "string", "description": "Label identifier for the report reason." },
+            "reason": { "type": "string", "maxLength": 2000, "description": "Optional free-text explanation." }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["id", "subject", "label", "reportedBy", "createdAt"],
+          "properties": {
+            "id": { "type": "integer" },
+            "subject": { "type": "unknown" },
+            "label": { "type": "string" },
+            "reason": { "type": "string" },
+            "reportedBy": { "type": "string", "format": "did" },
+            "createdAt": { "type": "string", "format": "datetime" }
+          }
+        }
+      }
+    },
+    "repoRef": {
+      "type": "object",
+      "required": ["did"],
+      "properties": {
+        "did": { "type": "string", "format": "did" }
+      }
+    },
+    "strongRef": {
+      "type": "object",
+      "required": ["uri", "cid"],
+      "properties": {
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/deleteRecord.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.deleteRecord",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a record via the user's PDS.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["collection", "rkey"],
+          "properties": {
+            "collection": { "type": "string" },
+            "rkey": { "type": "string" }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": { "type": "object", "properties": {} }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/describeCollections.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.describeCollections",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "List indexed collections and their schemas.",
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "collections": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "required": ["collection"],
+                "properties": {
+                  "collection": { "type": "string" },
+                  "columns": {
+                    "type": "array",
+                    "items": {
+                      "type": "object",
+                      "required": ["name", "originalName", "type", "required"],
+                      "properties": {
+                        "name": { "type": "string" },
+                        "originalName": { "type": "string" },
+                        "type": { "type": "string" },
+                        "required": { "type": "boolean" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/describeFeeds.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.describeFeeds",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "List available feeds.",
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "feeds": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "required": ["name", "label"],
+                "properties": {
+                  "name": { "type": "string" },
+                  "label": { "type": "string" }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/describeLabels.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.describeLabels",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "List available label definitions.",
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "definitions": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "required": ["identifier", "severity", "blurs", "defaultSetting"],
+                "properties": {
+                  "identifier": { "type": "string" },
+                  "severity": { "type": "string" },
+                  "blurs": { "type": "string" },
+                  "defaultSetting": { "type": "string" }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/getFeed.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.getFeed",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Retrieve a named feed of items.",
+      "parameters": {
+        "type": "params",
+        "required": ["feed"],
+        "properties": {
+          "feed": { "type": "string", "description": "Feed name" },
+          "limit": { "type": "integer", "minimum": 1, "maximum": 100, "default": 30 },
+          "cursor": { "type": "string" }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["items"],
+          "properties": {
+            "items": { "type": "array", "items": { "type": "unknown" } },
+            "cursor": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/getPreferences.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.getPreferences",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get all preferences for the authenticated user.",
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "preferences": { "type": "unknown" }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/getRecord.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.getRecord",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Fetch a single record by AT URI.",
+      "parameters": {
+        "type": "params",
+        "required": ["uri"],
+        "properties": {
+          "uri": { "type": "string", "format": "at-uri" }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "record": { "type": "unknown" }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/getRecords.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.getRecords",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "List records from a collection with optional filters.",
+      "parameters": {
+        "type": "params",
+        "required": ["collection"],
+        "properties": {
+          "collection": { "type": "string" },
+          "limit": { "type": "integer", "minimum": 1, "maximum": 100, "default": 20 },
+          "cursor": { "type": "string" },
+          "sort": { "type": "string" },
+          "order": { "type": "string" }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["items"],
+          "properties": {
+            "items": { "type": "array", "items": { "type": "unknown" } },
+            "cursor": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/putPreference.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.putPreference",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Set a single preference by key.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["key", "value"],
+          "properties": {
+            "key": { "type": "string" },
+            "value": { "type": "unknown" }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {}
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/putRecord.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.putRecord",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create or update a record via the user's PDS.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["collection", "rkey", "record"],
+          "properties": {
+            "collection": { "type": "string" },
+            "rkey": { "type": "string" },
+            "record": { "type": "unknown" },
+            "repo": { "type": "string", "format": "did" }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "uri": { "type": "string", "format": "at-uri" },
+            "cid": { "type": "string", "format": "cid" },
+            "commit": {
+              "type": "object",
+              "properties": {
+                "cid": { "type": "string", "format": "cid" },
+                "rev": { "type": "string" }
+              }
+            },
+            "validationStatus": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/searchRecords.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.searchRecords",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Full-text search across a collection.",
+      "parameters": {
+        "type": "params",
+        "required": ["collection", "q"],
+        "properties": {
+          "collection": { "type": "string" },
+          "q": { "type": "string", "description": "Search query" },
+          "limit": { "type": "integer", "minimum": 1, "maximum": 100, "default": 20 },
+          "cursor": { "type": "string" },
+          "fuzzy": { "type": "boolean", "default": true }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["items"],
+          "properties": {
+            "items": { "type": "array", "items": { "type": "unknown" } },
+            "cursor": { "type": "string" }
+          }
+        }
+      }
+    }
+  }
+}

packages/hatk/src/lexicons/dev/hatk/uploadBlob.json

···
+{
+  "lexicon": 1,
+  "id": "dev.hatk.uploadBlob",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Upload a blob via the user's PDS.",
+      "input": {
+        "encoding": "*/*"
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["blob"],
+          "properties": {
+            "blob": { "type": "blob" }
+          }
+        }
+      }
+    }
+  }
+}