@jingyi0605/codingns 0.8.0 → 0.8.5

package/node_modules/@codingns/session-sync-core/dist/types.d.ts

@@ -0,0 +1,198 @@
+import type { Stats } from "node:fs";
+export declare const BUILTIN_PROVIDER_IDS: readonly ["claude-code", "legna-code", "codex"];
+export type BuiltinProviderId = (typeof BUILTIN_PROVIDER_IDS)[number];
+export type ProviderId = BuiltinProviderId | (string & {});
+export type SessionRole = "user" | "assistant" | "tool" | "system";
+export type SyncStatus = "idle" | "syncing" | "error";
+export type MessageKind = "text" | "thinking" | "tool_call" | "tool_result";
+export type HistoryDirection = "forward" | "backward";
+export type InRunInputMode = "none" | "streaming_guidance" | "queued_guidance";
+export type ForkSourceType = "session" | "message";
+export type ForkMethod = "native_session_fork" | "native_message_fork" | "reconstructed_session_fork" | "reconstructed_message_fork";
+export type ForkStrategy = "auto" | "native-only" | "reconstruct-only";
+export interface ForkSourceMessageSnapshot {
+    role: SessionRole;
+    kind: MessageKind;
+    content: string;
+}
+export interface NormalizedMessageAttachment {
+    id: string;
+    kind: "image" | "file";
+    fileName: string;
+    mimeType: string;
+    fileSize: number;
+}
+export interface NormalizedToolCall {
+    callId: string;
+    name: string;
+    input: string;
+    output: string | null;
+    error: string | null;
+    status: "running" | "completed" | "failed";
+}
+export interface ProviderModelOption {
+    id: string;
+    name: string;
+    usesProviderDefault?: boolean;
+    supportedReasoningEfforts?: string[];
+}
+export interface ProviderCapabilities {
+    provider: ProviderId;
+    canStartSession: boolean;
+    canResumeSession: boolean;
+    canSendMessage: boolean;
+    inRunInputMode: InRunInputMode;
+    supportsSubagents: boolean;
+    supportsInterrupt: boolean;
+    supportsStructuredToolCalls: boolean;
+    supportsTokenUsage: boolean;
+    supportsAttachments: boolean;
+    supportsPermissionPrompt: boolean;
+    supportsCheckpoint: boolean;
+    supportsTodo?: boolean;
+    supportsSessionDiff?: boolean;
+    supportsPermissionRequests?: boolean;
+    supportsSessionFork?: boolean;
+    supportsSessionDelete?: boolean;
+    supportsSessionShare?: boolean;
+    supportsAsyncPrompt?: boolean;
+    supportsNativeAgents?: boolean;
+    modelOptions?: ProviderModelOption[];
+    defaultReasoningLevel?: string | null;
+    limitations: string[];
+}
+export type ContextUsageSource = "provider-log" | "provider-runtime" | "provider-config" | "model-map";
+export interface ContextUsageSnapshot {
+    provider: ProviderId;
+    promptTokens: number;
+    uncachedInputTokens: number;
+    cachedInputTokens: number;
+    contextWindow: number;
+    usageRatio: number;
+    source: ContextUsageSource;
+    contextWindowSource: ContextUsageSource;
+    modelId: string | null;
+    capturedAt: string | null;
+    isEstimated: boolean;
+}
+export interface ProviderSessionSummary {
+    provider: ProviderId;
+    providerSessionId: string;
+    title: string;
+    workspacePath: string;
+    rawStoreRef: string;
+    isArchived?: boolean;
+    lastMessageAt: string | null;
+    messageCount: number;
+    parentProviderSessionId?: string | null;
+    isSubagent?: boolean;
+    subagentLabel?: string | null;
+    sourceMtimeMs?: number;
+    sourceSizeBytes?: number;
+}
+export interface ProviderArchiveUpdateResult {
+    rawStoreRef: string;
+    isArchived: boolean;
+}
+export type ProviderDiscoveryStatus = "success" | "partial" | "failed";
+export interface ProviderDiscoveryDiagnostic {
+    provider: ProviderId;
+    status: ProviderDiscoveryStatus;
+    durationMs: number;
+    sessionCount: number;
+    isComplete: boolean;
+    errorMessage?: string | null;
+    scannedFiles?: number;
+    skippedByMtimeSize?: number;
+    parsedFiles?: number;
+    bytesRead?: number;
+}
+export interface ProviderSessionDiscovery {
+    sessions: ProviderSessionSummary[];
+    isComplete: boolean;
+    providerDiagnostics?: ProviderDiscoveryDiagnostic[];
+}
+export interface DetectSessionsOptions {
+    knownSessions?: ProviderSessionSummary[];
+}
+export interface NormalizedMessage {
+    messageId: string;
+    provider: ProviderId;
+    providerSessionId: string;
+    role: SessionRole;
+    kind: MessageKind;
+    content: string;
+    toolCall: NormalizedToolCall | null;
+    attachments?: NormalizedMessageAttachment[];
+    timestamp: string;
+    sequence: number;
+    rawRef: string;
+}
+export interface HistoryPage {
+    messages: NormalizedMessage[];
+    cursor: string | null;
+    nextCursor: string | null;
+    total: number;
+}
+export interface ResumeSessionResult {
+    provider: ProviderId;
+    providerSessionId: string;
+    resumedAt: string;
+    rawStoreRef: string;
+}
+export interface StartSessionOptions {
+    initialPrompt?: string;
+}
+export interface StartSessionResult {
+    session: ProviderSessionSummary;
+    initialCursor: string | null;
+}
+export interface ProviderRealtimeEvent {
+    messages: NormalizedMessage[];
+    cursor: string | null;
+}
+export interface SendMessageResult {
+    acceptedAt: string;
+    clientRequestId: string | null;
+    message: NormalizedMessage;
+}
+export interface ForkSessionOptions {
+    rawStoreRef: string;
+    sourceType: ForkSourceType;
+    sourceMessageId?: string | null;
+    sourceMessageSnapshot?: ForkSourceMessageSnapshot | null;
+    strategy?: ForkStrategy;
+}
+export interface ForkSessionResult {
+    session: ProviderSessionSummary;
+    forkMethod: ForkMethod;
+    forkSourceType: ForkSourceType;
+    inheritedPrefixMessageCount: number;
+    providerSourceMessageId?: string | null;
+}
+export interface ProviderSubscription {
+    close(): void;
+}
+export interface ProviderAdapter {
+    readonly providerId: ProviderId;
+    detectSessions(workspacePath: string, options?: DetectSessionsOptions): Promise<ProviderSessionSummary[]>;
+    detectSessionsDetailed?(workspacePath: string, options?: DetectSessionsOptions): Promise<ProviderSessionDiscovery>;
+    readRecentSessionHistory?(providerSessionId: string, rawStoreRef: string, totalMessageCount: number, limit: number): Promise<HistoryPage | null>;
+    readSessionHistory(providerSessionId: string, rawStoreRef: string, cursor: string | null, limit: number, direction?: HistoryDirection): Promise<HistoryPage>;
+    subscribeSession(providerSessionId: string, rawStoreRef: string, cursor: string | null, limit: number, onEvent: (event: ProviderRealtimeEvent) => Promise<void> | void): ProviderSubscription;
+    resumeSession(providerSessionId: string, rawStoreRef: string): Promise<ResumeSessionResult>;
+    startSession(workspacePath: string, options: StartSessionOptions): Promise<StartSessionResult>;
+    forkSession?(providerSessionId: string, workspacePath: string, options: ForkSessionOptions): Promise<ForkSessionResult>;
+    sendMessage(providerSessionId: string, rawStoreRef: string, content: string, clientRequestId: string | null, permissionMode?: string | null): Promise<SendMessageResult>;
+    readSessionTitle(providerSessionId: string, rawStoreRef: string): Promise<string>;
+    renameSessionTitle(providerSessionId: string, rawStoreRef: string, title: string): Promise<string>;
+    updateSessionArchiveState(providerSessionId: string, rawStoreRef: string, isArchived: boolean): Promise<ProviderArchiveUpdateResult>;
+    deleteSession?(providerSessionId: string, rawStoreRef: string): Promise<void>;
+    readContextUsage?(providerSessionId: string, rawStoreRef: string): Promise<ContextUsageSnapshot | null>;
+    getProviderCapabilities(): ProviderCapabilities;
+    getSessionCapabilities(providerSessionId: string): Promise<ProviderCapabilities>;
+}
+export interface ProviderFileDescriptor {
+    filePath: string;
+    stats: Stats;
+}

package/node_modules/@codingns/session-sync-core/dist/types.js

@@ -0,0 +1,2 @@
+export const BUILTIN_PROVIDER_IDS = ["claude-code", "legna-code", "codex"];
+//# sourceMappingURL=types.js.map

package/node_modules/@codingns/session-sync-core/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,aAAa,EAAE,YAAY,EAAE,OAAO,CAAU,CAAC"}

package/node_modules/@codingns/session-sync-core/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@codingns/session-sync-core",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runtime/claude-runtime": {
+      "types": "./dist/runtime/claude-runtime.d.ts",
+      "import": "./dist/runtime/claude-runtime.js"
+    },
+    "./runtime/types": {
+      "types": "./dist/runtime/types.d.ts",
+      "import": "./dist/runtime/types.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@openai/codex-sdk": "0.130.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "typescript": "^5.9.3"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jingyi0605/codingns",
-  "version": "0.8.0",
+  "version": "0.8.5",
   "type": "module",
   "bin": {
     "codingns": "./bin/codingns.mjs",
@@ -12,7 +12,8 @@
     "README.md",
     "scripts/postinstall.mjs",
     "node_modules/@codingns/session-sync-core",
-    "vendor"
+    "vendor",
+    "vendor-src/better-sqlite3-win32-x64-node22/README.md"
   ],
   "engines": {
     "node": ">=22.0.0"
@@ -23,7 +24,6 @@
   },
   "scripts": {
     "build": "node ./scripts/build.mjs",
-    "postpack": "node ./scripts/postpack.mjs",
     "postinstall": "node ./scripts/postinstall.mjs"
   },
   "publishConfig": {
@@ -34,7 +34,7 @@
     "@jackwener/opencli": "1.7.7",
     "@openai/codex": "0.130.0",
     "@openai/codex-sdk": "0.130.0",
-    "better-sqlite3": "^12.8.0",
+    "bindings": "^1.5.0",
     "chokidar": "^5.0.0",
     "fastify": "^5.8.2",
     "ignore": "^7.0.5",
@@ -44,7 +44,16 @@
     "ws": "^8.20.0"
   },
   "optionalDependencies": {
-    "@codingns/node-pty": "1.0.0-cns.1",
+    "@codingns/node-pty": "file:vendor/node-pty-fork",
     "node-pty": "^1.0.0"
-  }
+  },
+  "codingnsRuntimeDependencies": {
+    "betterSqlite3": "^12.8.0"
+  },
+  "codingnsWindowsRuntimePackages": {
+    "betterSqlite3": "file:vendor/better-sqlite3-win32-x64-node22"
+  },
+  "bundleDependencies": [
+    "@codingns/session-sync-core"
+  ]
 }

package/scripts/postinstall.mjs

@@ -12,6 +12,11 @@ const cliVersionRange = packageJson.dependencies?.["@openai/codex"];
 const sdkVersionRange = packageJson.dependencies?.["@openai/codex-sdk"];
 const sessionSyncCoreRange = packageJson.dependencies?.["@codingns/session-sync-core"];
 const windowsNodePtyRange = packageJson.optionalDependencies?.["@codingns/node-pty"];
+const betterSqliteRuntimeRange =
+  packageJson.codingnsRuntimeDependencies?.betterSqlite3 ??
+  packageJson.optionalDependencies?.["better-sqlite3"] ??
+  packageJson.dependencies?.["better-sqlite3"];
+const windowsBetterSqlitePackageSpec = packageJson.codingnsWindowsRuntimePackages?.betterSqlite3;
 
 if (!sdkVersionRange) {
   logInfo("[codingns] 未声明 @openai/codex-sdk，跳过 Codex 安装校验");
@@ -34,6 +39,10 @@ if (!verifyPtyRuntimeDependency()) {
   process.exit(1);
 }
 
+if (!(await ensureBetterSqliteRuntimeDependency())) {
+  process.exit(1);
+}
+
 if (await verifyCodexRuntime()) {
   logInfo("[codingns] Codex 运行时依赖已就绪");
   process.exit(0);
@@ -47,14 +56,7 @@ if (process.env.CODINGNS_SKIP_POSTINSTALL_REENTRY === "1") {
 logInfo("[codingns] 正在修复 Codex SDK 与当前平台二进制，请稍候...");
 cleanupBrokenCodexPackages();
 
-const repairResult = runNpmInstall([
-  "install",
-  "--no-save",
-  "--include=optional",
-  "--package-lock=false",
-  cliVersionRange ? `@openai/codex@${cliVersionRange}` : null,
-  `@openai/codex-sdk@${sdkVersionRange}`
-].filter(Boolean));
+const repairResult = repairCodexRuntime();
 
 if (repairResult.status !== 0) {
   process.exit(repairResult.status ?? 1);
@@ -91,6 +93,79 @@ function verifyPtyRuntimeDependency() {
   return true;
 }
 
+
+async function ensureBetterSqliteRuntimeDependency() {
+  let packageJsonPath = resolveModuleExportFile("better-sqlite3", "package.json");
+
+  if (!packageJsonPath) {
+    const installSpec = resolveBetterSqliteInstallSpec();
+
+    if (!installSpec) {
+      console.error(
+        `[codingns] 未找到 SQLite 运行时依赖：better-sqlite3${betterSqliteRuntimeRange ? `（默认上游版本 ${betterSqliteRuntimeRange}）` : ""}`
+      );
+      return false;
+    }
+
+    if (process.env.CODINGNS_SKIP_POSTINSTALL_REENTRY === "1") {
+      console.error(`[codingns] SQLite 运行时依赖修复后仍然缺失：${installSpec}`);
+      return false;
+    }
+
+    logInfo(`[codingns] 正在补装 SQLite 运行时依赖：${installSpec}`);
+    if (isWindowsManagedBetterSqliteInstallSpec(installSpec)) {
+      if (!copyManagedBetterSqliteRuntime(installSpec)) {
+        return false;
+      }
+    } else {
+      const installResult = runNpmInstall([
+        "install",
+        "--no-save",
+        "--package-lock=false",
+        "--install-strategy=nested",
+        installSpec
+      ]);
+
+      if (installResult.status !== 0) {
+        return false;
+      }
+    }
+
+    packageJsonPath = resolveModuleExportFile("better-sqlite3", "package.json");
+  }
+
+  if (!packageJsonPath) {
+    console.error(
+      `[codingns] 未找到 SQLite 运行时依赖：better-sqlite3${betterSqliteRuntimeRange ? `（默认上游版本 ${betterSqliteRuntimeRange}）` : ""}`
+    );
+    return false;
+  }
+
+  const sqlitePackageRoot = findPackageRoot(packageJsonPath) ?? path.dirname(packageJsonPath);
+  const sqlitePackageJsonPath = path.join(sqlitePackageRoot, "package.json");
+  const packageVersion = readPackageVersion(sqlitePackageJsonPath);
+  const actualPackageName = readPackageName(sqlitePackageJsonPath) || "better-sqlite3";
+  const packageSummary = packageVersion
+    ? `${actualPackageName}@${packageVersion}`
+    : actualPackageName;
+
+  if (actualPackageName !== "better-sqlite3") {
+    console.error(
+      `[codingns] 当前平台需要 better-sqlite3，但实际解析到了 ${actualPackageName}，说明安装结果混入了错误的平台包`
+    );
+    return false;
+  }
+
+  const nativeBindingPath = path.join(sqlitePackageRoot, "build", "Release", "better_sqlite3.node");
+  if (!fs.existsSync(nativeBindingPath)) {
+    console.error(`[codingns] SQLite 运行时缺少预编译产物：${actualPackageName}`);
+    return false;
+  }
+
+  logInfo(`[codingns] SQLite 运行时依赖已就绪：${packageSummary}`);
+  return true;
+}
+
 async function verifyCodexRuntime() {
   try {
     const sdkEntryPath =
@@ -138,6 +213,101 @@ async function verifyCodexRuntime() {
   }
 }
 
+
+
+function repairCodexRuntime() {
+  const installRoot = fs.mkdtempSync(path.join(packageRoot, ".codingns-codex-repair-"));
+
+  try {
+    const result = runNpmInstall([
+      "install",
+      "--no-save",
+      "--omit=optional",
+      "--package-lock=false",
+      ...resolveCodexRepairInstallSpecs()
+    ], {
+      prefix: installRoot,
+      cwd: installRoot
+    });
+
+    if (result.status !== 0) {
+      return result;
+    }
+
+    copyRepairedCodexPackages(installRoot);
+    return result;
+  } finally {
+    fs.rmSync(installRoot, { recursive: true, force: true });
+  }
+}
+
+function copyRepairedCodexPackages(installRoot) {
+  const sourceOpenAiRoot = path.join(installRoot, "node_modules", "@openai");
+  const targetNodeModulesRoot = path.join(packageRoot, "node_modules");
+  const targetOpenAiRoot = path.join(targetNodeModulesRoot, "@openai");
+  const targetBinRoot = path.join(targetNodeModulesRoot, ".bin");
+
+  if (!fs.existsSync(sourceOpenAiRoot)) {
+    throw new Error(`[codingns] Codex 修复结果缺少 @openai 包目录：${sourceOpenAiRoot}`);
+  }
+
+  fs.rmSync(targetOpenAiRoot, { recursive: true, force: true });
+  fs.mkdirSync(targetNodeModulesRoot, { recursive: true });
+  fs.cpSync(sourceOpenAiRoot, targetOpenAiRoot, { recursive: true });
+
+  copyRepairedCodexBin(installRoot, targetBinRoot);
+  logInfo(`[codingns] Codex 运行时依赖已复制到：${targetOpenAiRoot}`);
+}
+
+function copyRepairedCodexBin(installRoot, targetBinRoot) {
+  const sourceBinRoot = path.join(installRoot, "node_modules", ".bin");
+
+  fs.mkdirSync(targetBinRoot, { recursive: true });
+  for (const fileName of ["codex", "codex.cmd", "codex.ps1"]) {
+    const sourcePath = path.join(sourceBinRoot, fileName);
+    const targetPath = path.join(targetBinRoot, fileName);
+
+    fs.rmSync(targetPath, { force: true });
+    if (fs.existsSync(sourcePath)) {
+      fs.cpSync(sourcePath, targetPath);
+    }
+  }
+}
+
+function resolveCodexRepairInstallSpecs() {
+  const specs = [
+    cliVersionRange ? `@openai/codex@${cliVersionRange}` : null,
+    `@openai/codex-sdk@${sdkVersionRange}`,
+    resolveCodexPlatformInstallSpec()
+  ];
+
+  return specs.filter(Boolean);
+}
+
+function resolveCodexPlatformInstallSpec() {
+  const platformPackage = resolveCodexPlatformPackageName();
+  const platformVersion = resolveCodexPlatformPackageVersion();
+
+  if (!platformPackage || !platformVersion) {
+    return null;
+  }
+
+  return `${platformPackage}@npm:@openai/codex@${platformVersion}`;
+}
+
+function resolveCodexPlatformPackageVersion() {
+  if (typeof cliVersionRange !== "string") {
+    return null;
+  }
+
+  const exactVersionMatch = cliVersionRange.match(/^(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z-.]+)?)$/u);
+  if (!exactVersionMatch) {
+    return null;
+  }
+
+  return `${exactVersionMatch[1]}-${process.platform}-${process.arch}`;
+}
+
 function cleanupBrokenCodexPackages() {
   const openAiRoot = path.join(packageRoot, "node_modules", "@openai");
   const binRoot = path.join(packageRoot, "node_modules", ".bin");
@@ -148,7 +318,7 @@ function cleanupBrokenCodexPackages() {
   fs.rmSync(path.join(binRoot, "codex.ps1"), { force: true });
 }
 
-function runNpmInstall(args) {
+function runNpmInstall(args, options = {}) {
   const env = {
     ...process.env,
     CODINGNS_SKIP_POSTINSTALL_REENTRY: "1",
@@ -158,11 +328,13 @@ function runNpmInstall(args) {
   delete env.npm_config_prefix;
   delete env.npm_command;
 
+  const installPrefix = options.prefix ?? packageRoot;
+  const installCwd = options.cwd ?? packageRoot;
   const installArgs = [
     ...args,
     "--global=false",
     "--prefix",
-    packageRoot,
+    installPrefix,
     "--install-strategy=nested"
   ];
 
@@ -172,7 +344,7 @@ function runNpmInstall(args) {
   );
 
   const result = spawnSync(command.file, command.args, {
-    cwd: packageRoot,
+    cwd: installCwd,
     env,
     stdio: "inherit"
   });
@@ -362,6 +534,71 @@ function readPackageVersion(packageJsonPath) {
   }
 }
 
+function readPackageName(packageJsonPath) {
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return typeof packageJson?.name === "string" ? packageJson.name : "";
+  } catch {
+    return "";
+  }
+}
+
+function resolveBetterSqliteInstallSpec() {
+  if (
+    process.platform === "win32" &&
+    process.arch === "x64" &&
+    Number((process.versions.node || "").split(".")[0]) === 22
+  ) {
+    return windowsBetterSqlitePackageSpec ?? null;
+  }
+
+  if (betterSqliteRuntimeRange) {
+    return `better-sqlite3@${betterSqliteRuntimeRange}`;
+  }
+
+  return "better-sqlite3";
+}
+
+function isWindowsManagedBetterSqliteInstallSpec(installSpec) {
+  return (
+    process.platform === "win32" &&
+    process.arch === "x64" &&
+    Number((process.versions.node || "").split(".")[0]) === 22 &&
+    typeof installSpec === "string" &&
+    installSpec.startsWith("file:")
+  );
+}
+
+function copyManagedBetterSqliteRuntime(installSpec) {
+  const sourceDirectory = resolveFileInstallSpecPath(installSpec);
+  if (!sourceDirectory || !fs.existsSync(path.join(sourceDirectory, "package.json"))) {
+    console.error(`[codingns] Windows SQLite 受控包不存在：${installSpec}`);
+    return false;
+  }
+
+  const sourceBinaryPath = path.join(sourceDirectory, "build", "Release", "better_sqlite3.node");
+  if (!fs.existsSync(sourceBinaryPath)) {
+    console.error(`[codingns] Windows SQLite 受控包缺少预编译产物：${sourceBinaryPath}`);
+    return false;
+  }
+
+  const targetDirectory = path.join(packageRoot, "node_modules", "better-sqlite3");
+  fs.rmSync(targetDirectory, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(targetDirectory), { recursive: true });
+  fs.cpSync(sourceDirectory, targetDirectory, { recursive: true });
+  logInfo(`[codingns] SQLite 运行时依赖已复制到：${targetDirectory}`);
+  return true;
+}
+
+function resolveFileInstallSpecPath(installSpec) {
+  if (typeof installSpec !== "string" || !installSpec.startsWith("file:")) {
+    return null;
+  }
+
+  const filePath = installSpec.slice("file:".length);
+  return path.resolve(packageRoot, filePath);
+}
+
 function resolveRequiredPtyPackageName() {
   if (
     process.platform === "win32" &&

package/vendor/better-sqlite3-win32-x64-node22/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Joshua Wise
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/vendor/better-sqlite3-win32-x64-node22/README.md

@@ -0,0 +1,12 @@
+# `better-sqlite3`（CodingNS Windows 受控包）
+
+这是 CodingNS 自维护的 `better-sqlite3` Windows 运行时包。
+
+目标很窄：
+
+- 只支持 `win32 + x64 + Node 22`
+- 包名保持 `better-sqlite3`，这样 npm 安装时不会再把“依赖名”和“真实包名”装成两套
+- 只给 `@jingyi0605/codingns` 的正式安装使用
+- 不接受安装阶段再回退到本机 `node-gyp rebuild`
+
+它不是通用发布包，也不是给工作区开发时直接依赖的源码包。