hide-a-bed 5.2.8 → 6.0.0

package/impl/{trackedEmitter.mjs → utils/trackedEmitter.mts}

@@ -1,21 +1,23 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
 import { EventEmitter } from 'events'
 
 export class TrackedEmitter extends EventEmitter {
   // create a constructor with some options
-  constructor (options) {
+  constructor(options) {
     super(options)
     if (options.delay) this.delay = options.delay
   }
 
-  emit (event, ...args) {
+  emit(event, ...args) {
     const listeners = this.listeners(event)
     let completed = 0
 
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       if (!listeners || listeners.length === 0) {
         return resolve() // no listeners? no delay
       }
-      listeners.forEach((listener) => {
+      listeners.forEach(listener => {
         listener(...args)
         completed++
         if (completed === listeners.length) {
@@ -27,7 +29,7 @@ export class TrackedEmitter extends EventEmitter {
   }
 }
 
-export const setupEmitter = (config) => {
-  if (!config._emitter) return ({ emit: async () => {} })
-  return config._emitter
+export const setupEmitter = config => {
+  if (!config['~emitter']) return { emit: async () => {} }
+  return config['~emitter']
 }

package/impl/utils/transactionErrors.mts

@@ -0,0 +1,71 @@
+export class TransactionSetupError extends Error {
+  details: Record<string, unknown>
+
+  constructor(message: string, details: Record<string, unknown> = {}) {
+    super(message)
+    this.name = 'TransactionSetupError'
+    this.details = details
+  }
+}
+
+export class TransactionVersionConflictError extends Error {
+  conflictingIds: string[]
+
+  constructor(conflictingIds: string[]) {
+    super(`Revision mismatch for documents: ${conflictingIds.join(', ')}`)
+    this.name = 'TransactionVersionConflictError'
+    this.conflictingIds = conflictingIds
+  }
+}
+
+export class TransactionBulkOperationError extends Error {
+  failedDocs: {
+    ok?: boolean | null
+    id?: string | null
+    rev?: string | null
+    error?: string | null
+    reason?: string | null
+  }[]
+
+  constructor(
+    failedDocs: Array<{
+      ok?: boolean | null
+      id?: string | null
+      rev?: string | null
+      error?: string | null
+      reason?: string | null
+    }>
+  ) {
+    super(`Failed to save documents: ${failedDocs.map(d => d.id).join(', ')}`)
+    this.name = 'TransactionBulkOperationError'
+    this.failedDocs = failedDocs
+  }
+}
+
+export class TransactionRollbackError extends Error {
+  originalError: Error
+  rollbackResults: {
+    ok?: boolean | null
+    id?: string | null
+    rev?: string | null
+    error?: string | null
+    reason?: string | null
+  }[]
+
+  constructor(
+    message: string,
+    originalError: Error,
+    rollbackResults: Array<{
+      ok?: boolean | null
+      id?: string | null
+      rev?: string | null
+      error?: string | null
+      reason?: string | null
+    }>
+  ) {
+    super(message)
+    this.name = 'TransactionRollbackError'
+    this.originalError = originalError
+    this.rollbackResults = rollbackResults
+  }
+}

package/index.mts

@@ -0,0 +1,82 @@
+import { createQuery } from './impl/utils/queryBuilder.mts'
+import { QueryBuilder } from './impl/utils/queryBuilder.mts'
+import { bindConfig } from './impl/bindConfig.mts'
+import { withRetry } from './impl/retry.mts'
+import { bulkGet, bulkGetDictionary } from './impl/bulkGet.mts'
+import { getAtRev, get } from './impl/get.mts'
+import { queryStream } from './impl/stream.mts'
+import { patch, patchDangerously } from './impl/patch.mts'
+import { put } from './impl/put.mts'
+import { remove } from './impl/remove.mts'
+import { bulkSave, bulkSaveTransaction } from './impl/bulkSave.mts'
+import { query } from './impl/query.mts'
+import { getDBInfo } from './impl/getDBInfo.mts'
+import { bulkRemove, bulkRemoveMap } from './impl/bulkRemove.mts'
+import { createLock, removeLock } from './impl/sugar/lock.mts'
+import { watchDocs } from './impl/sugar/watch.mts'
+
+export {
+  get,
+  getAtRev,
+  put,
+  remove,
+  bulkGet,
+  bulkSave,
+  query,
+  queryStream,
+  getDBInfo,
+
+  // sugar methods
+  patch,
+  patchDangerously,
+  bulkRemove,
+  bulkRemoveMap,
+  bulkGetDictionary,
+  bulkSaveTransaction,
+  watchDocs,
+
+  // binding
+  bindConfig,
+  withRetry,
+
+  // utils
+  QueryBuilder,
+  createQuery,
+  createLock,
+  removeLock
+}
+
+export type {
+  BulkGetBound,
+  BulkGetDictionaryBound,
+  BulkGetDictionaryOptions,
+  BulkGetDictionaryResult,
+  BulkGetOptions,
+  BulkGetResponse
+} from './impl/bulkGet.mts'
+export type { OnInvalidDocAction } from './impl/utils/parseRows.mts'
+export type { GetOptions, GetBound, GetAtRevBound } from './impl/get.mts'
+export type { QueryBound } from './impl/query.mts'
+export type {
+  ViewString,
+  ViewOptions as SimpleViewOptions
+} from './schema/couch/couch.input.schema.ts'
+export type {
+  ViewRow,
+  CouchDoc,
+  CouchDocInput,
+  ViewQueryResponse,
+  ViewQueryResponseValidated,
+  ViewRowValidated
+} from './schema/couch/couch.output.schema.ts'
+export type { RetryOptions } from './impl/retry.mts'
+export type { NetworkError, RetryableError, NotFoundError } from './impl/utils/errors.mts'
+export type { OnRow } from './impl/stream.mts'
+export type { CouchConfig, CouchConfigInput } from './schema/config.mts'
+export type { LockOptions, LockOptionsInput, LockDoc } from './schema/sugar/lock.mts'
+export type {
+  WatchOptions as WatchOptionsSchema,
+  WatchOptionsInput
+} from './schema/sugar/watch.mts'
+export type { BoundInstance } from './impl/bindConfig.mts'
+export type { StandardSchemaV1 } from './types/standard-schema.ts'

package/migration_guides/v6.md

@@ -0,0 +1,70 @@
+# hide-a-bed v6 Migration Guide
+
+## When to read this
+
+- Teams upgrading projects that currently depend on hide-a-bed v5.x.
+- Consumers who maintain custom stubs or wrappers around the public APIs.
+- Anyone who relied on the bundled `_changes` helper that shipped before v6.
+
+## Upgrade checklist
+
+- Update hide-a-bed and, if you use the changed feed, install the companion `hide-a-bed-changes` package.
+- Run `npm run build` and your existing integration tests against a CouchDB instance or the project stub.
+
+## Breaking changes
+
+### Config object will throw if passed unknown properties
+
+- The `Config` constructor now validates its input and will throw if unknown properties are present.
+- Review any custom config objects to ensure only supported properties are included.
+
+### Function errors changed
+
+- Previously all functions were zod validated and would throw `ZodError` on invalid input or output.
+- Functions are no longer zod validated by default, inputs and outputs are validated as needed but mostly types are enforced at compile time.
+- If you relied on catching `ZodError`, you will need to adjust your error handling to accommodate the new error types thrown by the client.
+
+### View Query keys will be encoded by default
+
+- Previously, users would have to call `encodeURIComponent` on keys passed to view queries that required encoding.
+- Now, the client automatically encodes keys.
+- If you previously encoded keys manually, you will need to decode them before passing to the query helpers to avoid double-encoding.
+
+### View Query paths types are more strict
+
+- The path string passed to `query` will show a type error if it does not match the `ViewString` union.
+
+```ts
+export type ViewString = '_all_docs' | `_design/${string}/_view/${string}`
+```
+
+### `_changes` feed split out of the core client
+
+- The polling helper that wrapped `changes-stream` no longer ships inside the client bundle.
+- Use the dedicated package shown in [changes/README.md](changes/README.md) to restore the previous feed behaviour.
+
+### Schema builder exports removed
+
+- The legacy `schema.*` namespace is gone; internal Zod v4 Standard Schema assets stay private.
+- Test doubles that previously used `schema.BulkSave.implementAsync` now need to migrate to the maintained stub package or copy the v5 schema layer.
+- All runtime APIs still accept plain objects, while TypeScript users can import the inferred types exposed from [client/index.mts](client/index.mts) (for example `CouchDoc`, `ViewQueryResponse`).
+
+## Additional opt-in changes
+
+### Validation options
+
+- Some doc and view queries now accept and optional `validate` option
+- `bulkGet`, `bulkGetDictionary`, `query`, and `get` all can use and optional `options.validate.docSchema` and friends (see [client/impl/bulkGet.mts](client/impl/bulkGet.mts) and [client/impl/query.mts](client/impl/query.mts)).
+
+```ts
+// v5 style
+await bulkGet(config, ids)
+
+// v6 style
+await bulkGet(config, ids, {
+  validate: {
+    docSchema,
+    onInvalidDoc: 'skip'
+  }
+})
+```

package/package.json

@@ -1,23 +1,37 @@
 {
   "name": "hide-a-bed",
-  "version": "5.2.8",
+  "version": "6.0.0",
   "description": "An abstraction over couchdb calls that includes easy mock/stubs with pouchdb",
-  "module": "index.mjs",
-  "main": "cjs/index.cjs",
   "type": "module",
-  "types": "index.d.mts",
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/esm/index.mjs",
+  "types": "./types/output/index.d.mts",
   "exports": {
-    "require": "./cjs/index.cjs",
-    "import": "./index.mjs",
-    "default": "./cjs/index.cjs"
+    "default": "./dist/cjs/index.cjs",
+    "types": "./types/output/index.d.mts",
+    "require": {
+      "types": "./types/output/index.d.mts",
+      "default": "./dist/cjs/index.cjs"
+    },
+    "import": {
+      "types": "./types/output/index.d.mts",
+      "default": "./dist/esm/index.mjs"
+    }
   },
   "scripts": {
-    "clean": "rm -rf cjs && (find . -name \"*.mts\" -type f -delete || true) && (find . -name \"*.map\" -type f -delete || true) && (find . -name \"log.txt\" -type f -delete || true)",
-    "build": "npm run clean && tsc && npx -p dualmode@latest build",
-    "build:cjs": "rm -rf cjs && node build/build.mjs",
-    "test": "node tests/*.mjs",
-    "lint:fix": "standard --fix",
-    "prepublish": "npm run build",
+    "clean": "rm -rf types/output && rm -rf dist && (find . -name \"log.txt\" -type f -delete || true)",
+    "build": "npm run clean && tsc && tsdown",
+    "build:docs": "typedoc ./index.mts",
+    "dev": "typedoc --watch ./index.mts & npx -y serve ./docs",
+    "test": "node --test --test-global-setup ./test/setup.mts",
+    "test:watch": "node --test --watch --test-global-setup ./test/setup.mts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "typecheck": "tsc --noEmit",
+    "typecheck:watch": "tsc --noEmit --watch",
+    "prepublishOnly": "npm run build",
     "full": "npm run lint:fix && npm run build && npm run clean"
   },
   "repository": {
@@ -35,27 +49,30 @@
   },
   "homepage": "https://github.com/ryanramage/hide-a-bed#readme",
   "dependencies": {
-    "changes-stream": "^2.2.0",
-    "JSONStream": "^1.3.5",
-    "lodash": "^4.17.21",
-    "needle": "^3.2.0",
-    "zod": "^3.22.4"
+    "needle": "3.3.1",
+    "stream-chain": "3.4.0",
+    "stream-json": "1.9.1",
+    "zod": "4.2.1"
   },
   "devDependencies": {
-    "@types/lodash": "^4.17.15",
-    "@types/needle": "^3.3.0",
-    "esbuild": "^0.24.2",
-    "glob": "^11.0.0",
-    "install": "^0.13.0",
-    "npm": "^11.1.0",
-    "pouchdb-server": "^4.2.0",
-    "standard": "17.1.0",
-    "tap": "^21.0.2",
-    "tape": "5.8.1",
-    "typescript": "5.6.2"
+    "@eslint/js": "9.39.2",
+    "@types/needle": "3.3.0",
+    "@types/node": "22.19.3",
+    "@types/stream-json": "1.7.8",
+    "eslint": "9.39.2",
+    "globals": "16.5.0",
+    "pouchdb-server": "4.2.0",
+    "prettier": "3.7.4",
+    "tsdown": "0.18.1",
+    "typedoc": "0.28.15",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.50.1"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
   },
   "volta": {
-    "node": "20.17.0",
-    "npm": "10.8.2"
+    "node": "24.12.0",
+    "npm": "11.6.2"
   }
-}
+}

package/schema/config.mts

@@ -0,0 +1,81 @@
+import { z } from 'zod'
+import type { StandardSchemaV1 } from '../types/standard-schema.ts'
+
+const anyArgs = z.array(z.any())
+
+const LoggerSchema = z
+  .object({
+    error: z.function({ input: anyArgs, output: z.void() }).optional(),
+    warn: z.function({ input: anyArgs, output: z.void() }).optional(),
+    info: z.function({ input: anyArgs, output: z.void() }).optional(),
+    debug: z.function({ input: anyArgs, output: z.void() }).optional()
+  })
+  .or(z.function({ input: anyArgs, output: z.void() }))
+
+export const NeedleBaseOptions = z.object({
+  json: z.boolean(),
+  headers: z.record(z.string(), z.string()),
+  parse_response: z.boolean().optional()
+})
+export type NeedleBaseOptionsSchema = z.infer<typeof NeedleBaseOptions>
+
+export const NeedleOptions = z.object({
+  json: z.boolean().optional(),
+  compressed: z.boolean().optional(),
+  follow_max: z.number().optional(),
+  follow_set_cookie: z.boolean().optional(),
+  follow_set_referer: z.boolean().optional(),
+  follow: z.number().optional(),
+  timeout: z.number().optional(),
+  read_timeout: z.number().optional(),
+  parse_response: z.boolean().optional(),
+  decode: z.boolean().optional(),
+  parse_cookies: z.boolean().optional(),
+  cookies: z.record(z.string(), z.string()).optional(),
+  headers: z.record(z.string(), z.string()).optional(),
+  auth: z.enum(['auto', 'digest', 'basic']).optional(),
+  username: z.string().optional(),
+  password: z.string().optional(),
+  proxy: z.string().optional(),
+  agent: z.any().optional(),
+  rejectUnauthorized: z.boolean().optional(),
+  output: z.string().optional(),
+  parse: z.boolean().optional(),
+  multipart: z.boolean().optional(),
+  open_timeout: z.number().optional(),
+  response_timeout: z.number().optional(),
+  keepAlive: z.boolean().optional()
+})
+
+export const CouchConfig = z
+  .strictObject({
+    backoffFactor: z.number().optional().default(2).describe('multiplier for exponential backoff'),
+    bindWithRetry: z.boolean().optional().default(true).describe('should we bind with retry'),
+    couch: z.string().describe('the url of the couch db'),
+    initialDelay: z
+      .number()
+      .optional()
+      .default(1000)
+      .describe('initial retry delay in milliseconds'),
+    logger: LoggerSchema.optional().describe(
+      'logging interface supporting winston-like or simple function interface'
+    ),
+    maxRetries: z.number().optional().default(3).describe('maximum number of retry attempts'),
+    needleOpts: NeedleOptions.optional(),
+    throwOnGetNotFound: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe('if a get is 404 should we throw or return undefined'),
+    useConsoleLogger: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe('turn on console as a fallback logger'),
+    '~emitter': z.any().optional().describe('emitter for events'),
+    '~normalizedLogger': z.any().optional() // Internal property for caching normalized logger
+  })
+  .describe('The std config object')
+
+export type CouchConfig = StandardSchemaV1.InferOutput<typeof CouchConfig>
+export type CouchConfigInput = StandardSchemaV1.InferInput<typeof CouchConfig>

package/schema/couch/couch.input.schema.ts

@@ -0,0 +1,43 @@
+import z from 'zod'
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts'
+
+export type ViewString = '_all_docs' | `_design/${string}/_view/${string}`
+
+export const ViewOptions = z
+  .object({
+    descending: z.boolean().optional().describe('sort results descending'),
+    endkey_docid: z
+      .string()
+      .optional()
+      .describe('stop returning records when this document ID is reached'),
+    endkey: z.any().optional(),
+    group_level: z.number().positive().optional().describe('group the results at this level'),
+    group: z.boolean().optional().describe('group the results'),
+    include_docs: z.boolean().optional().describe('join the id to the doc and return it'),
+    inclusive_end: z
+      .boolean()
+      .optional()
+      .describe('whether the endkey is included in the result, default true'),
+    key: z.any().optional(),
+    keys: z.array(z.any()).optional(),
+    limit: z.number().nonnegative().optional().describe('limit the results to this many rows'),
+    reduce: z.boolean().optional().describe('reduce the results'),
+    skip: z.number().nonnegative().optional().describe('skip this many rows'),
+    sorted: z.boolean().optional().describe('sort returned rows, default true'),
+    stable: z
+      .boolean()
+      .optional()
+      .describe('ensure the view index is not updated during the query, default false'),
+    startkey: z.any().optional(),
+    startkey_docid: z
+      .string()
+      .optional()
+      .describe('start returning records when this document ID is reached'),
+    update: z
+      .enum(['true', 'false', 'lazy'])
+      .optional()
+      .describe('whether to update the view index before returning results, default true'),
+    update_seq: z.boolean().optional().describe('include the update sequence in the result')
+  })
+  .describe('base options for a CouchDB view query')
+export type ViewOptions = StandardSchemaV1.InferOutput<typeof ViewOptions>

package/schema/couch/couch.output.schema.ts

@@ -0,0 +1,169 @@
+import { z } from 'zod'
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts'
+
+/**
+ * Default schema for a returned CouchDB document if no validation schema is provided.
+ */
+export const CouchDoc = z.looseObject({
+  _id: z.string().describe('the couch doc id'),
+  _rev: z.string().optional().nullish().describe('the doc revision'),
+  _deleted: z.boolean().optional().describe('is the doc deleted')
+})
+export type CouchDoc = StandardSchemaV1.InferOutput<typeof CouchDoc>
+
+/**
+ * A type for input CouchDB documents (without required _id).
+ */
+export type CouchDocInput = Omit<CouchDoc, '_id'> & { _id?: string }
+
+/**
+ * Default schema for a CouchDB view row if no validation schema is provided.
+ */
+export const ViewRow = z.object({
+  id: z.string().optional(),
+  key: z.any().nullish(),
+  value: z.any().nullish(),
+  doc: CouchDoc.nullish(),
+  error: z.string().optional().describe('usually not_found, if something is wrong with this doc')
+})
+export type ViewRow = StandardSchemaV1.InferOutput<typeof ViewRow>
+
+/**
+ * A CouchDB view row with validated key, value, and document schemas.
+ */
+export type ViewRowValidated<
+  DocSchema extends StandardSchemaV1,
+  KeySchema extends StandardSchemaV1,
+  ValueSchema extends StandardSchemaV1
+> = {
+  id?: string
+  key?: StandardSchemaV1.InferOutput<KeySchema>
+  value?: StandardSchemaV1.InferOutput<ValueSchema>
+  doc?: StandardSchemaV1.InferOutput<DocSchema>
+  error?: string
+}
+
+/**
+ * Response type for a CouchDB view query if no validation schemas are provided.
+ */
+export const ViewQueryResponse = z.object({
+  total_rows: z.number().nonnegative().optional().describe('total rows in the view'),
+  offset: z
+    .number()
+    .nonnegative()
+    .optional()
+    .describe('the offset of the first row in this result set'),
+  error: z.string().optional().describe('if something is wrong'),
+  rows: z.array(ViewRow).optional().describe('the rows returned by the view'),
+  update_seq: z
+    .number()
+    .optional()
+    .describe('the update sequence of the database at the time of the query')
+})
+export type ViewQueryResponse = StandardSchemaV1.InferOutput<typeof ViewQueryResponse>
+
+/**
+ * Response type for a CouchDB view query with validated key, value, and document schemas.
+ */
+export type ViewQueryResponseValidated<
+  DocSchema extends StandardSchemaV1,
+  KeySchema extends StandardSchemaV1 = StandardSchemaV1<unknown>,
+  ValueSchema extends StandardSchemaV1 = StandardSchemaV1<unknown>
+> = Omit<ViewQueryResponse, 'rows'> & {
+  rows: Array<ViewRowValidated<DocSchema, KeySchema, ValueSchema>>
+}
+
+/**
+ * CouchDB _bulk_docs response schema
+ */
+export const BulkSaveResponse = z.array(
+  z.object({
+    ok: z.boolean().nullish(),
+    id: z.string().nullish(),
+    rev: z.string().nullish(),
+    error: z.string().nullish().describe('if an error occurred, one word reason, eg conflict'),
+    reason: z.string().nullish().describe('a full error message')
+  })
+)
+export type BulkSaveResponse = z.infer<typeof BulkSaveResponse>
+
+export const CouchPutResponse = z.object({
+  ok: z.boolean().optional().describe('did the request succeed'),
+  error: z.string().optional().describe('the error message, if did not succeed'),
+  statusCode: z.number(),
+  id: z.string().optional().describe('the couch doc id'),
+  rev: z.string().optional().describe('the new rev of the doc')
+})
+
+export const CouchDBInfo = z.looseObject({
+  cluster: z
+    .object({
+      n: z.number().describe('Replicas. The number of copies of every document.').optional(),
+      q: z.number().describe('Shards. The number of range partitions.').optional(),
+      r: z
+        .number()
+        .describe(
+          'Read quorum. The number of consistent copies of a document that need to be read before a successful reply.'
+        )
+        .optional(),
+      w: z
+        .number()
+        .describe(
+          'Write quorum. The number of copies of a document that need to be written before a successful reply.'
+        )
+        .optional()
+    })
+    .optional(),
+  compact_running: z
+    .boolean()
+    .describe('Set to true if the database compaction routine is operating on this database.')
+    .optional(),
+  db_name: z.string().describe('The name of the database.'),
+  disk_format_version: z
+    .number()
+    .describe('The version of the physical format used for the data when it is stored on disk.')
+    .optional(),
+  doc_count: z.number().describe('A count of the documents in the specified database.').optional(),
+  doc_del_count: z.number().describe('Number of deleted documents').optional(),
+  instance_start_time: z.string().optional(),
+  purge_seq: z
+    .string()
+    .describe(
+      'An opaque string that describes the purge state of the database. Do not rely on this string for counting the number of purge operations.'
+    )
+    .optional(),
+  sizes: z
+    .object({
+      active: z
+        .number()
+        .describe('The size of live data inside the database, in bytes.')
+        .optional(),
+      external: z
+        .number()
+        .describe('The uncompressed size of database contents in bytes.')
+        .optional(),
+      file: z
+        .number()
+        .describe(
+          'The size of the database file on disk in bytes. Views indexes are not included in the calculation.'
+        )
+        .optional()
+    })
+    .optional(),
+  update_seq: z
+    .string()
+    .or(z.number())
+    .describe(
+      'An opaque string that describes the state of the database. Do not rely on this string for counting the number of updates.'
+    )
+    .optional(),
+  props: z
+    .object({
+      partitioned: z
+        .boolean()
+        .describe('If present and true, this indicates that the database is partitioned.')
+        .optional()
+    })
+    .optional()
+})
+export type CouchDBInfo = z.infer<typeof CouchDBInfo>

package/schema/sugar/lock.mts

@@ -0,0 +1,18 @@
+import { z } from 'zod'
+import { CouchDoc } from '../couch/couch.output.schema.ts'
+import type { StandardSchemaV1 } from '../../types/standard-schema.ts'
+
+export const LockDoc = CouchDoc.extend({
+  type: z.literal('lock'),
+  locks: z.string().describe('the document ID being locked'),
+  lockedAt: z.string().describe('ISO timestamp when lock was created'),
+  lockedBy: z.string().describe('username of who created the lock')
+})
+export type LockDoc = StandardSchemaV1.InferOutput<typeof LockDoc>
+
+export const LockOptions = z.object({
+  enableLocking: z.boolean().prefault(true).describe('whether locking is enabled'),
+  username: z.string().describe('username to attribute locks to')
+})
+export type LockOptions = StandardSchemaV1.InferOutput<typeof LockOptions>
+export type LockOptionsInput = StandardSchemaV1.InferInput<typeof LockOptions>