Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@docker/docker-compose.yml`:
- Around line 245-256: The SurrealDB service uses the floating image tag
"surrealdb/surrealdb:latest" which can cause non-reproducible builds; update the
surrealdb service's image field to a specific versioned tag (e.g., replace
:latest with a known semver or SHA) so the image is pinned, then document or add
a comment with the chosen version and rationale; look for the surrealdb service
block and change the image string accordingly.

In `@packages/adapter-surrealdb/package.json`:
- Around line 37-40: Update the "surrealdb" dependency in package.json from
"^1.0.0" to "^2.0.0" (i.e., change the value for the surrealdb entry under
"dependencies"); before committing, review SurrealDB 2.0.x changelog for
breaking changes and run adapter tests/compile against the new surrealdb API to
fix any incompatibilities in code that references SurrealDB client
methods/classes.

In `@packages/adapter-surrealdb/src/conversion.ts`:
- Around line 126-132: The code currently returns new Date(arg) and uses
atob(...) without validating input; update the conversion logic around arg and
argType.scalarType so that for 'datetime' you construct the Date, check
isNaN(date.getTime()) and throw a descriptive Error (or return a controlled
failure) on invalid dates, and for 'bytes' wrap the atob call in a try/catch (or
pre-validate with a base64 regex) and throw a descriptive Error if decoding
fails before calling Uint8Array.from; reference the existing arg and
argType.scalarType checks in conversion.ts and ensure the thrown errors include
the invalid input context.
- Around line 8-11: Add a short JSDoc/comment to the inferColumnType function
documenting the null/undefined inference strategy: state that inferColumnType
returns ColumnTypeEnum.Text for null or undefined as a conservative fallback,
explain that this is ambiguous when first-row values are null and may lead to
incorrect column typing, and note recommended mitigations (e.g., scanning
additional rows before inferring, providing an explicit schema override, or
treating nulls as unknown). Reference the inferColumnType function and the use
of ColumnTypeEnum.Text so reviewers can find and understand the rationale and
suggested safeguards.

In `@packages/adapter-surrealdb/src/errors.ts`:
- Around line 125-127: The isSurrealDbError type guard is too broad (it matches
any Error); tighten it to detect SurrealDbError-specific shape by checking a
discriminant or unique property (e.g., check (error as SurrealDbError).code !==
undefined or (error as SurrealDbError).name === 'SurrealDbError' or another
property that exists on SurrealDbError), or if the guard is intentionally meant
as a catch‑all, add a clear JSDoc comment stating that intent; update the
isSurrealDbError function and/or the SurrealDbError type so the guard reliably
distinguishes SurrealDbError from generic Error.

In `@packages/adapter-surrealdb/src/index.ts`:
- Line 1: Add an inline documentation comment for the new public export so the
package API is documented: above the export statement that re-exports
PrismaSurrealDbAdapterFactory as PrismaSurrealDb, add a concise doc comment
describing what PrismaSurrealDb represents (that it is a factory/adapter for
SurrealDB integration with Prisma), any important usage notes or return/behavior
expectations, and mark it as public API; ensure the comment appears immediately
above the export of PrismaSurrealDb so tooling and generated docs pick it up.

In `@packages/adapter-surrealdb/src/surrealdb.ts`:
- Line 1: Remove the file-wide "/* eslint-disable
`@typescript-eslint/require-await` */" and instead apply the rule only where
necessary: either make the methods comply (remove unnecessary async or add
awaited calls) or place an inline disable comment directly above the specific
async methods that legitimately do not await (e.g., the dispose method and any
other functions named with async in the file). Replace the top-of-file disable
with per-method comments like "/* eslint-disable-next-line
`@typescript-eslint/require-await` */" immediately before the affected function
declarations (or refactor the functions to remove async) to limit the scope.
- Around line 24-27: Replace the exported type alias PrismaSurrealDbOptions with
an exported interface of the same name that defines the same optional properties
(namespace?: string, database?: string); update any references (imports/uses) to
PrismaSurrealDbOptions if needed to ensure the symbol remains exported and
compatible. Ensure the interface is exported (export interface
PrismaSurrealDbOptions { namespace?: string; database?: string; }) and run type
checks to confirm no changes are required where the type alias was previously
used.
- Around line 201-221: The connect() method can leak the Surreal client if
client.connect() or client.use() throws; update connect() so that when
this.#externalClient is not provided you create the Surreal instance and then
wrap the connect/use calls in a try/catch/finally (or try with a cleanup on
error) to ensure client.close() is called on any failure before rethrowing the
error, but keep the current behavior of not closing externally provided clients
when this.#externalClient is set and return PrismaSurrealDbAdapter as before.
- Around line 147-161: The startTransaction method ignores the _isolationLevel
parameter; update startTransaction to respect or at least surface non-default
isolation requests: detect if _isolationLevel is provided, map it to SurrealDB's
supported isolation syntax or set it on the TransactionOptions object
(referencing startTransaction, TransactionOptions, and SurrealDbTransaction),
and include it when issuing the BEGIN TRANSACTION (or pass it into the
SurrealDbTransaction constructor); if SurrealDB does not support configurable
isolation levels, log a clear warning when _isolationLevel is non-default and/or
document the limitation instead of silently ignoring the parameter.
- Around line 86-101: The performIO method builds bindings with numeric keys
which SurrealDB does not accept; change it to produce a bindings object with the
exact named parameter keys used in the SQL (e.g., "$userId", "$email") before
calling this.client.query. Use the SqlQuery data (inspect argTypes or add param
name metadata to SqlQuery if missing) and map each mappedArgs[i] to a binding
key that matches the placeholder in sql (prefix with "$" or use the
argTypes[i].name), update the bindings construction in performIO (and keep using
mapArg for value conversion), then call this.client.query(sql, bindings);
preserve the existing error handling via this.onError.

In `@packages/migrate/src/__tests__/__helpers__/conditionalTests.ts`:
- Line 20: The test matrix currently enables surrealdb unconditionally (the
allProviders/conditionalTests entry "surrealdb: true"), which makes CI brittle;
update the provider matrix so surrealdb is only enabled when an env flag is set
(e.g., process.env.RUN_SURREALDB or similar) or add a skip guard check in the
conditionalTests helper so surrealdb is skipped by default; locate the
allProviders/conditionalTests symbol and replace the unconditional "surrealdb:
true" with a conditional expression that reads an environment variable (or adds
surrealdb to the existing skip list) so CI runs remain controllable.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/adapter-surrealdb/src/conversion.ts`:
- Around line 109-110: The conversion logic in conversion.ts currently
JSON.stringify()s all objects except Uint8Array, which corrupts ArrayBuffer
values (they become "{}"); update the check around the variable value so
ArrayBuffer and ArrayBufferViews are excluded from JSON.stringify — detect them
via value instanceof ArrayBuffer and ArrayBuffer.isView(value) (or equivalent)
and let them pass through/be handled as binary (consistent with inferColumnType
classifying Bytes) instead of being serialized to JSON.

In `@packages/adapter-surrealdb/src/errors.ts`:
- Around line 14-43: Add a documentation comment for the exported function
convertDriverError describing its purpose as the adapter's error-translation
boundary, inputs and possible output shapes, and behavior for different error
kinds (socket, TLS, SurrealDB, generic Error, and rethrowing unknown values);
place the comment immediately above the convertDriverError declaration and
reference the returned DriverAdapterErrorObject and the helper predicates
mapSocketError, isSocketError, isTlsError, isSurrealDbError, and
mapSurrealDbError so callers understand which error classes are converted and
what callers can expect.

In `@packages/adapter-surrealdb/src/surrealdb.ts`:
- Around line 22-25: Add JSDoc-style documentation comments for the exported
types: PrismaSurrealDbOptions (describe purpose and optional namespace/database
properties), PrismaSurrealDbAdapter (describe adapter role and key
methods/contract), and PrismaSurrealDbAdapterFactory (describe factory signature
and return value). Update the module’s other exported items in the 138-186 range
in the same way—provide one-line description of each export, expected
inputs/outputs and any important behaviour or invariants. Keep comments concise,
use standard /** ... */ format, and ensure the documented symbols
(PrismaSurrealDbOptions, PrismaSurrealDbAdapter, PrismaSurrealDbAdapterFactory)
match the exact exported names.
- Around line 204-225: connect() currently passes this.#url directly into new
Surreal().connect(), which ignores embedded credentials; parse the datasource
URL (this.#url) to extract username and password and supply them to the Surreal
client (either via connect() options or by calling client.signin()) before
opening the connection; update the branch that creates new Surreal() in
connect() to parse credentials, call client.connect(parsedUrlWithoutCredentials)
and then authenticate with the extracted credentials, ensuring the
external-client branch that returns new
PrismaSurrealDbAdapter(this.#externalClient, ...) remains unchanged.
- Around line 139-143: The constructor currently declares TypeScript private
parameters for options and release; refactor them to native private fields by
adding class-level declarations `#options?: PrismaSurrealDbOptions` and
`#release?: () => Promise<void>` and remove `private readonly` from the
constructor parameter list, then assign the incoming arguments to these fields
inside the constructor (e.g., this.#options = options; this.#release =
release;). Update usages in methods `getConnectionInfo()` and `dispose()` to
reference `this.#options` and `this.#release` respectively. Ensure imports/types
remain unchanged and preserve existing behavior and types.

---

Duplicate comments:
In `@packages/migrate/src/__tests__/__helpers__/conditionalTests.ts`:
- Around line 13-22: allProviders currently includes "surrealdb" which causes
tests (via noDriverAdapters reusing allProviders) to opt into SurrealDB
prematurely; remove the surrealdb entry from the allProviders object (or set it
to false) so SurrealDB is not enabled by default, and if you need opt-in test
coverage add a separate optInProviders list or explicit flag used by tests to
include "surrealdb" until the prisma-engines work lands; update references to
allProviders/noDriverAdapters to use the new opt-in mechanism if necessary.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/adapter-surrealdb/src/conversion.ts`:
- Around line 128-130: The list-handling branch in mapArg incorrectly passes the
same argType (with arity 'list') to recursive calls; change the recursive call
inside the Array.isArray(arg) && argType.arity === 'list' branch to call mapArg
for each element with argType modified to arity: 'scalar' (e.g., create a
shallow copy of argType with arity set to 'scalar') so nested arrays are not
reinterpreted as lists and inner elements get scalar conversions (reference:
mapArg and argType).

In `@packages/adapter-surrealdb/src/surrealdb.ts`:
- Around line 221-240: connectUrl can remain with the surrealdb:// scheme when
no credentials are present, causing WebSocket connection failures; ensure the
scheme is normalized to ws:// or wss:// regardless of credentials by converting
the original this.#url (and the parsed URL) to the appropriate ws(s) scheme.
Update the parsing block around parseable/parsed/connectUrl so that after
constructing parseable (and after any credential removal) you always set
connectUrl to the parsed.toString() with the protocol replaced: use wss:// if
the original this.#url starts with surrealdbs:// (or preserve a trailing "s" if
present), otherwise use ws://; keep username/password decoding and removal logic
intact (symbols: this.#url, parseable, parsed, username, password, connectUrl).

In `@packages/migrate/src/__tests__/__helpers__/conditionalTests.ts`:
- Around line 24-26: Add a JSDoc/doc comment above the exported surrealdbOnly
constant describing that it is a test matrix helper which restricts providers to
only the SurrealDB provider, note that it satisfies the Matrix type, and include
a brief one-line usage example or intent (e.g., "Use in tests to run only
against the SurrealDB provider"). Keep the comment consistent with other
exported helper docs in the repo (short description, mention it's exported, and
any expected shape if helpful).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/adapter-surrealdb/src/__tests__/surrealdb.test.ts`:
- Line 13: Remove the non-informative inline comments that restate test intent
(e.g. the comment string "// Type-level test: ensure the interface shape is
correct" and the similar comment around line 30) from the test file so the tests
read self‑documenting; if there is important context or rationale to preserve,
move that explanation into a brief higher‑level comment above the relevant
describe/test block explaining the "why", otherwise delete the inline comments
from the test cases (look for the exact comment text mentioned to locate them).
- Line 31: Tests mix CommonJS require with ESM imports; update each test that
does "const { PrismaSurrealDb } = require('../index')" (and the three other
similar require usages) to use dynamic ESM import via "const { PrismaSurrealDb }
= await import('../index')" and mark those test callbacks async so you can await
the import; ensure all tests use the same pattern as the existing async import
in the file to keep module loading consistent.

In `@packages/client/tests/functional/surrealdb-crud/tests.ts`:
- Around line 9-12: Remove the redundant banner-style section comments (e.g.,
the "CREATE" banner and other repeated "========" blocks) throughout the tests
file; delete those comment blocks that only restate structure (the ones around
CRUD sections) so the test file contains only meaningful inline comments
explaining why, not what; ensure no test code or descriptions are removed and
run tests to confirm formatting changes didn't affect behavior.
- Around line 13-312: Many tests share and mutate global state (e.g., records
created via prisma.user.create in tests like "create a single user", "create a
user with a related post", and mutate/update/delete tests), causing cascade
failures; make each test independent by either (a) creating its own unique test
data (use a unique email suffix or timestamp in each test when calling
prisma.user.create / prisma.user.upsert) and cleaning it up at the end of that
same test (call prisma.user.delete or prisma.user.deleteMany for that email), or
(b) add a setup/teardown hook (beforeEach/afterEach) that resets relevant tables
with prisma.user.deleteMany({ where: { email: { contains: 'test-suffix' } } })
or truncates the test dataset so tests like "update a single user", "delete a
single user", "findUnique by email", "aggregate - avg, min, max", and
transaction tests operate on isolated records; apply the same pattern for
related entities (posts) created via posts.create in the "create a user with a
related post" test.

In `@packages/client/tests/functional/surrealdb-types/tests.ts`:
- Around line 9-11: Remove the redundant banner comment blocks (the repeated "//
============================================================" and the section
title comments like "// ALL SCALAR TYPES") that appear before test groups (e.g.,
the block at the top and the similar blocks around lines with the text blocks
for 59-61, 83-85, 108-110, 137-139, 173-175); leave the existing test case names
and descriptions intact (they already describe the tests), so simply delete
those banner comment lines to reduce noise and keep tests lean.
- Around line 99-106: The test "unique field findUnique" is order-dependent
because it assumes a record inserted by "unique constraint enforced"; make it
independent by creating or upserting the required record inside the test itself
before calling prisma.uniqueTest.findUnique. Specifically, add a setup step in
the test that uses prisma.uniqueTest.create or prisma.uniqueTest.upsert (with
where: { code: 'ALPHA' } and data: { code: 'ALPHA', value: 1 }) to ensure the
record exists, then run the existing findUnique/assertions; this guarantees the
test no longer depends on prior tests.
- Around line 92-97: The test currently uses a generic rejects.toThrow() for
prisma.uniqueTest.create; change it to assert the Prisma error name and code
instead. Replace the expect(...).rejects.toThrow() with an assertion like await
expect(prisma.uniqueTest.create(...)).rejects.toMatchObject({ name:
'PrismaClientKnownRequestError', code: '<EXPECTED_CODE>' }) (use the actual
Prisma error code for the unique constraint, e.g. 'P2002'), so the test checks
both result.name and result.code rather than any thrown error.