@dobby.ai/dobby 0.1.0 → 0.1.1

package/src/core/routing.ts

@@ -1,19 +1,20 @@
-import { existsSync, readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { z } from "zod";
+import { isDobbyRepoRoot } from "../shared/dobby-repo.js";
 import { BUILTIN_HOST_SANDBOX_ID } from "./types.js";
 import type {
   BindingConfig,
   BindingResolution,
   BindingSource,
   ConnectorsConfig,
+  DefaultBindingConfig,
   ExtensionInstanceConfig,
   ExtensionsConfig,
   GatewayConfig,
   ProvidersConfig,
-  RouteDefaultsConfig,
+  RouteDefaultConfig,
   RouteProfile,
   RouteResolution,
   RoutesConfig,
@@ -24,7 +25,8 @@ const extensionItemSchema = z.object({
   type: z.string().trim().min(1),
 }).catchall(z.unknown());
 
-const routeDefaultsSchema = z.object({
+const routeDefaultSchema = z.object({
+  projectRoot: z.string().trim().min(1).optional(),
   provider: z.string().trim().min(1).optional(),
   sandbox: z.string().trim().min(1).optional(),
   tools: z.enum(["full", "readonly"]).optional(),
@@ -32,7 +34,7 @@ const routeDefaultsSchema = z.object({
 }).strict();
 
 const routeItemSchema = z.object({
-  projectRoot: z.string().trim().min(1),
+  projectRoot: z.string().trim().min(1).optional(),
   tools: z.enum(["full", "readonly"]).optional(),
   mentions: z.enum(["required", "optional"]).optional(),
   provider: z.string().trim().min(1).optional(),
@@ -54,6 +56,10 @@ const bindingItemSchema = z.object({
   route: z.string().trim().min(1),
 }).strict();
 
+const defaultBindingSchema = z.object({
+  route: z.string().trim().min(1),
+}).strict();
+
 const gatewayConfigSchema = z.object({
   extensions: z.object({
     allowList: z
@@ -77,10 +83,11 @@ const gatewayConfigSchema = z.object({
     items: z.record(z.string(), extensionItemSchema).default({}),
   }).strict(),
   routes: z.object({
-    defaults: routeDefaultsSchema.default({}),
+    default: routeDefaultSchema.default({}),
     items: z.record(z.string(), routeItemSchema),
   }).strict(),
   bindings: z.object({
+    default: defaultBindingSchema.optional(),
     items: z.record(z.string(), bindingItemSchema).default({}),
   }).strict(),
   data: z.object({
@@ -99,24 +106,6 @@ const FORBIDDEN_CONNECTOR_CONFIG_KEYS: Record<string, string> = {
   botTokenEnv: "Set botToken directly in connector config or inject it before the config is loaded.",
 };
 
-function isDobbyRepoRoot(candidateDir: string): boolean {
-  const packageJsonPath = resolve(candidateDir, "package.json");
-  const repoConfigPath = resolve(candidateDir, "config", "gateway.json");
-  const localExtensionsScriptPath = resolve(candidateDir, "scripts", "local-extensions.mjs");
-
-  if (!existsSync(packageJsonPath) || !existsSync(repoConfigPath) || !existsSync(localExtensionsScriptPath)) {
-    return false;
-  }
-
-  try {
-    const packageJsonRaw = readFileSync(packageJsonPath, "utf-8");
-    const parsed = JSON.parse(packageJsonRaw) as { name?: unknown };
-    return parsed.name === "dobby";
-  } catch {
-    return false;
-  }
-}
-
 function resolveConfigBaseDir(configPath: string): string {
   const absoluteConfigPath = resolve(configPath);
   const configDir = dirname(absoluteConfigPath);
@@ -192,12 +181,18 @@ function normalizeSandboxes(parsed: ParsedGatewayConfig["sandboxes"]): Sandboxes
 }
 
 function normalizeRouteProfile(
+  routeId: string,
   baseDir: string,
   profile: ParsedRouteItem,
-  defaults: RouteDefaultsConfig,
+  defaults: RouteDefaultConfig,
 ): RouteProfile {
+  const resolvedProjectRoot = profile.projectRoot ?? defaults.projectRoot;
+  if (!resolvedProjectRoot) {
+    throw new Error(`routes.items['${routeId}'].projectRoot is required when routes.default.projectRoot is not set`);
+  }
+
   const normalized: RouteProfile = {
-    projectRoot: resolveMaybeAbsolute(baseDir, profile.projectRoot),
+    projectRoot: resolveMaybeAbsolute(baseDir, resolvedProjectRoot),
     tools: profile.tools ?? defaults.tools,
     mentions: profile.mentions ?? defaults.mentions,
     provider: profile.provider ?? defaults.provider,
@@ -211,14 +206,14 @@ function normalizeRouteProfile(
   return normalized;
 }
 
-function normalizeRoutes(parsed: ParsedGatewayConfig["routes"], baseDir: string, defaults: RouteDefaultsConfig): RoutesConfig {
+function normalizeRoutes(parsed: ParsedGatewayConfig["routes"], baseDir: string, defaults: RouteDefaultConfig): RoutesConfig {
   const items: Record<string, RouteProfile> = {};
   for (const [routeId, profile] of Object.entries(parsed.items)) {
-    items[routeId] = normalizeRouteProfile(baseDir, profile, defaults);
+    items[routeId] = normalizeRouteProfile(routeId, baseDir, profile, defaults);
   }
 
   return {
-    defaults,
+    default: defaults,
     items,
   };
 }
@@ -236,7 +231,10 @@ function normalizeBindings(parsed: ParsedGatewayConfig["bindings"]): GatewayConf
     };
   }
 
-  return { items };
+  return {
+    ...(parsed.default ? { default: { route: parsed.default.route } } : {}),
+    items,
+  };
 }
 
 function validateConnectorConfigKeys(parsed: ParsedGatewayConfig["connectors"]): void {
@@ -259,18 +257,18 @@ function validateReferences(parsed: ParsedGatewayConfig, normalizedRoutes: Route
     throw new Error(`sandboxes.default '${defaultSandbox}' does not exist in sandboxes.items`);
   }
 
-  const resolvedDefaults: RouteDefaultsConfig = {
-    provider: parsed.routes.defaults.provider ?? parsed.providers.default,
-    sandbox: parsed.routes.defaults.sandbox ?? parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID,
-    tools: parsed.routes.defaults.tools ?? "full",
-    mentions: parsed.routes.defaults.mentions ?? "required",
+  const resolvedDefaults: RouteDefaultConfig = {
+    provider: parsed.routes.default.provider ?? parsed.providers.default,
+    sandbox: parsed.routes.default.sandbox ?? parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID,
+    tools: parsed.routes.default.tools ?? "full",
+    mentions: parsed.routes.default.mentions ?? "required",
   };
 
   if (!parsed.providers.items[resolvedDefaults.provider]) {
-    throw new Error(`routes.defaults.provider references unknown provider '${resolvedDefaults.provider}'`);
+    throw new Error(`routes.default.provider references unknown provider '${resolvedDefaults.provider}'`);
   }
   if (resolvedDefaults.sandbox !== BUILTIN_HOST_SANDBOX_ID && !parsed.sandboxes.items[resolvedDefaults.sandbox]) {
-    throw new Error(`routes.defaults.sandbox references unknown sandbox '${resolvedDefaults.sandbox}'`);
+    throw new Error(`routes.default.sandbox references unknown sandbox '${resolvedDefaults.sandbox}'`);
   }
 
   for (const [routeId, profile] of Object.entries(normalizedRoutes.items)) {
@@ -300,6 +298,10 @@ function validateReferences(parsed: ParsedGatewayConfig, normalizedRoutes: Route
     }
     seenSources.set(bindingKey, bindingId);
   }
+
+  if (parsed.bindings.default && !normalizedRoutes.items[parsed.bindings.default.route]) {
+    throw new Error(`bindings.default.route references unknown route '${parsed.bindings.default.route}'`);
+  }
 }
 
 export async function loadGatewayConfig(configPath: string): Promise<GatewayConfig> {
@@ -309,11 +311,12 @@ export async function loadGatewayConfig(configPath: string): Promise<GatewayConf
   const parsed = gatewayConfigSchema.parse(JSON.parse(raw) as unknown);
   validateConnectorConfigKeys(parsed.connectors);
 
-  const routeDefaults: RouteDefaultsConfig = {
-    provider: parsed.routes.defaults.provider ?? parsed.providers.default,
-    sandbox: parsed.routes.defaults.sandbox ?? parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID,
-    tools: parsed.routes.defaults.tools ?? "full",
-    mentions: parsed.routes.defaults.mentions ?? "required",
+  const routeDefaults: RouteDefaultConfig = {
+    ...(parsed.routes.default.projectRoot ? { projectRoot: resolveMaybeAbsolute(configBaseDir, parsed.routes.default.projectRoot) } : {}),
+    provider: parsed.routes.default.provider ?? parsed.providers.default,
+    sandbox: parsed.routes.default.sandbox ?? parsed.sandboxes.default ?? BUILTIN_HOST_SANDBOX_ID,
+    tools: parsed.routes.default.tools ?? "full",
+    mentions: parsed.routes.default.mentions ?? "required",
   };
 
   const normalizedRoutes = normalizeRoutes(parsed.routes, configBaseDir, routeDefaults);
@@ -340,7 +343,7 @@ export async function loadGatewayConfig(configPath: string): Promise<GatewayConf
 }
 
 export class RouteResolver {
-  constructor(private readonly routes: RoutesConfig) {}
+  constructor(private readonly routes: RoutesConfig) { }
 
   resolve(routeId: string): RouteResolution | null {
     const normalizedRouteId = routeId.trim();
@@ -355,6 +358,7 @@ export class RouteResolver {
 
 export class BindingResolver {
   private readonly bindingsBySource = new Map<string, BindingResolution>();
+  private readonly defaultBinding: BindingResolution | null;
 
   constructor(bindings: GatewayConfig["bindings"]) {
     for (const [bindingId, binding] of Object.entries(bindings.items)) {
@@ -363,14 +367,35 @@ export class BindingResolver {
         config: binding,
       });
     }
+
+    this.defaultBinding = bindings.default
+      ? {
+        bindingId: "__default__",
+        config: {
+          connector: "__default__",
+          source: {
+            type: "chat",
+            id: "__direct_message__",
+          },
+          route: bindings.default.route,
+        },
+      }
+      : null;
   }
 
-  resolve(connectorId: string, source: BindingSource): BindingResolution | null {
+  resolve(
+    connectorId: string,
+    source: BindingSource,
+    options?: {
+      isDirectMessage?: boolean;
+    },
+  ): BindingResolution | null {
     if (!connectorId.trim() || !source.id.trim()) {
-      return null;
+      return options?.isDirectMessage ? this.defaultBinding : null;
     }
 
-    return this.bindingsBySource.get(this.buildKey(connectorId, source)) ?? null;
+    return this.bindingsBySource.get(this.buildKey(connectorId, source))
+      ?? (options?.isDirectMessage ? this.defaultBinding : null);
   }
 
   private buildKey(connectorId: string, source: BindingSource): string {

package/src/core/types.ts

@@ -106,7 +106,8 @@ export interface ConnectorPlugin {
   stop(): Promise<void>;
 }
 
-export interface RouteDefaultsConfig {
+export interface RouteDefaultConfig {
+  projectRoot?: string;
   provider: string;
   sandbox: string;
   tools: ToolProfile;
@@ -123,7 +124,7 @@ export interface RouteProfile {
 }
 
 export interface RoutesConfig {
-  defaults: RouteDefaultsConfig;
+  default: RouteDefaultConfig;
   items: Record<string, RouteProfile>;
 }
 
@@ -161,7 +162,12 @@ export interface BindingConfig {
   route: string;
 }
 
+export interface DefaultBindingConfig {
+  route: string;
+}
+
 export interface BindingsConfig {
+  default?: DefaultBindingConfig;
   items: Record<string, BindingConfig>;
 }
 

package/src/shared/dobby-repo.ts

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+const DOBBY_REPO_PACKAGE_NAMES = new Set(["dobby", "@dobby.ai/dobby"]);
+
+function readPackageName(candidateDir: string): string | undefined {
+  const packageJsonPath = resolve(candidateDir, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return undefined;
+  }
+
+  try {
+    const packageJsonRaw = readFileSync(packageJsonPath, "utf-8");
+    const parsed = JSON.parse(packageJsonRaw) as { name?: unknown };
+    return typeof parsed.name === "string" ? parsed.name : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function isDobbyRepoRoot(candidateDir: string): boolean {
+  const repoConfigPath = resolve(candidateDir, "config", "gateway.json");
+  const repoConfigExamplePath = resolve(candidateDir, "config", "gateway.example.json");
+  const localExtensionsScriptPath = resolve(candidateDir, "scripts", "local-extensions.mjs");
+
+  if ((!existsSync(repoConfigPath) && !existsSync(repoConfigExamplePath)) || !existsSync(localExtensionsScriptPath)) {
+    return false;
+  }
+
+  const packageName = readPackageName(candidateDir);
+  return packageName !== undefined && DOBBY_REPO_PACKAGE_NAMES.has(packageName);
+}
+
+export function findDobbyRepoRoot(startDir: string): string | null {
+  let currentDir = resolve(startDir);
+
+  while (true) {
+    if (isDobbyRepoRoot(currentDir)) {
+      return currentDir;
+    }
+
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}

package/config/models.custom.example.json

@@ -1,27 +0,0 @@
-{
-  "providers": {
-    "custom-openai": {
-      "baseUrl": "https://api.example.com/v1",
-      "api": "openai-completions",
-      "apiKey": "CUSTOM_PROVIDER_AUTH_TOKEN",
-      "models": [
-        {
-          "id": "example-model",
-          "name": "example-model",
-          "reasoning": false,
-          "input": [
-            "text"
-          ],
-          "contextWindow": 128000,
-          "maxTokens": 8192,
-          "cost": {
-            "input": 0,
-            "output": 0,
-            "cacheRead": 0,
-            "cacheWrite": 0
-          }
-        }
-      ]
-    }
-  }
-}

package/dist/src/agent/tests/event-forwarder.test.js

@@ -1,113 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { EventForwarder } from "../event-forwarder.js";
-class FakeConnector {
-    id = "connector.test";
-    platform = "test";
-    name = "test";
-    capabilities;
-    sent = [];
-    sentCount = 0;
-    constructor(updateStrategy, maxTextLength) {
-        this.capabilities = {
-            updateStrategy,
-            supportsThread: false,
-            supportsTyping: false,
-            supportsFileUpload: false,
-            ...(maxTextLength !== undefined ? { maxTextLength } : {}),
-        };
-    }
-    async start(_ctx) { }
-    async send(message) {
-        this.sent.push(message);
-        this.sentCount += 1;
-        return { messageId: `msg-${this.sentCount}` };
-    }
-    async stop() { }
-}
-const noopLogger = {
-    info: () => { },
-    warn: () => { },
-    error: () => { },
-    debug: () => { },
-};
-function createInbound() {
-    return {
-        connectorId: "connector.test",
-        platform: "test",
-        accountId: "bot",
-        routeId: "route.main",
-        routeChannelId: "route.main",
-        chatId: "chat.main",
-        messageId: "inbound-1",
-        userId: "user-1",
-        text: "hello",
-        attachments: [],
-        timestampMs: Date.now(),
-        raw: {},
-        isDirectMessage: false,
-        mentionedBot: true,
-    };
-}
-function sleep(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-test("edit strategy keeps create+update flow", async () => {
-    const connector = new FakeConnector("edit");
-    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
-        updateIntervalMs: 1,
-    });
-    forwarder.handleEvent({ type: "message_complete", text: "hello" });
-    await sleep(5);
-    forwarder.handleEvent({ type: "message_complete", text: "hello world" });
-    await sleep(5);
-    await forwarder.finalize();
-    assert.equal(connector.sent.length, 2);
-    assert.equal(connector.sent[0]?.mode, "create");
-    assert.equal(connector.sent[0]?.text, "hello");
-    assert.equal(connector.sent[1]?.mode, "update");
-    assert.equal(connector.sent[1]?.text, "hello world");
-});
-test("final_only suppresses tool/status outbound messages", async () => {
-    const connector = new FakeConnector("final_only");
-    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
-        toolMessageMode: "all",
-        updateIntervalMs: 1,
-    });
-    forwarder.handleEvent({ type: "status", message: "starting" });
-    forwarder.handleEvent({ type: "tool_start", toolName: "bash" });
-    forwarder.handleEvent({ type: "message_delta", delta: "hello " });
-    forwarder.handleEvent({ type: "tool_end", toolName: "bash", isError: false, output: "ok" });
-    forwarder.handleEvent({ type: "message_delta", delta: "world" });
-    await forwarder.finalize();
-    assert.equal(connector.sent.length, 1);
-    assert.equal(connector.sent[0]?.mode, "create");
-    assert.equal(connector.sent[0]?.text, "hello world");
-});
-test("final_only splits long final text into multiple create messages", async () => {
-    const connector = new FakeConnector("final_only", 5);
-    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger);
-    forwarder.handleEvent({ type: "message_complete", text: "12345678901" });
-    await forwarder.finalize();
-    assert.equal(connector.sent.length, 3);
-    assert.deepEqual(connector.sent.map((message) => ({ mode: message.mode, text: message.text })), [
-        { mode: "create", text: "12345" },
-        { mode: "create", text: "67890" },
-        { mode: "create", text: "1" },
-    ]);
-});
-test("append sends streaming increments as create messages only", async () => {
-    const connector = new FakeConnector("append");
-    const forwarder = new EventForwarder(connector, createInbound(), null, noopLogger, {
-        updateIntervalMs: 5,
-    });
-    forwarder.handleEvent({ type: "message_delta", delta: "hello" });
-    await sleep(20);
-    forwarder.handleEvent({ type: "message_delta", delta: " world" });
-    await sleep(20);
-    await forwarder.finalize();
-    assert.deepEqual(connector.sent.map((message) => message.mode), ["create", "create"]);
-    assert.deepEqual(connector.sent.map((message) => message.text), ["hello", " world"]);
-});

package/dist/src/cli/shared/config-path.js

@@ -1,207 +0,0 @@
-const BLOCKED_OBJECT_KEYS = new Set(["__proto__", "prototype", "constructor"]);
-/**
- * Returns true when a path segment represents an array index.
- */
-function isIndexSegment(raw) {
-    return /^[0-9]+$/.test(raw);
-}
-/**
- * Rejects dangerous object keys that could enable prototype pollution.
- */
-function validatePathSegments(path) {
-    for (const segment of path) {
-        if (!isIndexSegment(segment) && BLOCKED_OBJECT_KEYS.has(segment)) {
-            throw new Error(`Invalid path segment: ${segment}`);
-        }
-    }
-}
-/**
- * Parses dot/bracket path syntax into normalized path segments.
- */
-export function parsePath(rawPath) {
-    const trimmed = rawPath.trim();
-    if (!trimmed) {
-        return [];
-    }
-    const segments = [];
-    let current = "";
-    let index = 0;
-    while (index < trimmed.length) {
-        const char = trimmed[index];
-        if (char === "\\") {
-            const next = trimmed[index + 1];
-            if (next) {
-                current += next;
-            }
-            index += 2;
-            continue;
-        }
-        if (char === ".") {
-            if (current) {
-                segments.push(current);
-            }
-            current = "";
-            index += 1;
-            continue;
-        }
-        if (char === "[") {
-            if (current) {
-                segments.push(current);
-            }
-            current = "";
-            const closeIndex = trimmed.indexOf("]", index);
-            if (closeIndex === -1) {
-                throw new Error(`Invalid path (missing ']'): ${rawPath}`);
-            }
-            const inside = trimmed.slice(index + 1, closeIndex).trim();
-            if (!inside) {
-                throw new Error(`Invalid path (empty '[]'): ${rawPath}`);
-            }
-            segments.push(inside);
-            index = closeIndex + 1;
-            continue;
-        }
-        current += char;
-        index += 1;
-    }
-    if (current) {
-        segments.push(current);
-    }
-    const normalized = segments.map((segment) => segment.trim()).filter(Boolean);
-    validatePathSegments(normalized);
-    return normalized;
-}
-/**
- * Safe own-property check wrapper.
- */
-function hasOwnKey(value, key) {
-    return Object.prototype.hasOwnProperty.call(value, key);
-}
-/**
- * Reads a value from object/array structures by parsed path segments.
- */
-export function getAtPath(root, path) {
-    let current = root;
-    for (const segment of path) {
-        if (!current || typeof current !== "object") {
-            return { found: false };
-        }
-        if (Array.isArray(current)) {
-            if (!isIndexSegment(segment)) {
-                return { found: false };
-            }
-            const index = Number.parseInt(segment, 10);
-            if (!Number.isFinite(index) || index < 0 || index >= current.length) {
-                return { found: false };
-            }
-            current = current[index];
-            continue;
-        }
-        const record = current;
-        if (!hasOwnKey(record, segment)) {
-            return { found: false };
-        }
-        current = record[segment];
-    }
-    return { found: true, value: current };
-}
-/**
- * Sets a value at path, creating intermediate objects/arrays as needed.
- */
-export function setAtPath(root, path, value) {
-    if (path.length === 0) {
-        throw new Error("Path is empty.");
-    }
-    let current = root;
-    for (let i = 0; i < path.length - 1; i += 1) {
-        const segment = path[i];
-        const next = path[i + 1];
-        const nextIsIndex = Boolean(next && isIndexSegment(next));
-        if (Array.isArray(current)) {
-            if (!isIndexSegment(segment)) {
-                throw new Error(`Expected numeric index for array segment '${segment}'`);
-            }
-            const index = Number.parseInt(segment, 10);
-            const existing = current[index];
-            if (!existing || typeof existing !== "object") {
-                current[index] = nextIsIndex ? [] : {};
-            }
-            current = current[index];
-            continue;
-        }
-        if (!current || typeof current !== "object") {
-            throw new Error(`Cannot traverse into '${segment}' (not an object)`);
-        }
-        const record = current;
-        const existing = hasOwnKey(record, segment) ? record[segment] : undefined;
-        if (!existing || typeof existing !== "object") {
-            record[segment] = nextIsIndex ? [] : {};
-        }
-        current = record[segment];
-    }
-    const tail = path[path.length - 1];
-    if (Array.isArray(current)) {
-        if (!isIndexSegment(tail)) {
-            throw new Error(`Expected numeric index for array segment '${tail}'`);
-        }
-        const index = Number.parseInt(tail, 10);
-        current[index] = value;
-        return;
-    }
-    if (!current || typeof current !== "object") {
-        throw new Error(`Cannot set '${tail}' (parent is not an object)`);
-    }
-    current[tail] = value;
-}
-/**
- * Removes a value at path and returns whether the target existed.
- */
-export function unsetAtPath(root, path) {
-    if (path.length === 0) {
-        return false;
-    }
-    let current = root;
-    for (let i = 0; i < path.length - 1; i += 1) {
-        const segment = path[i];
-        if (!current || typeof current !== "object") {
-            return false;
-        }
-        if (Array.isArray(current)) {
-            if (!isIndexSegment(segment)) {
-                return false;
-            }
-            const index = Number.parseInt(segment, 10);
-            if (!Number.isFinite(index) || index < 0 || index >= current.length) {
-                return false;
-            }
-            current = current[index];
-            continue;
-        }
-        const record = current;
-        if (!hasOwnKey(record, segment)) {
-            return false;
-        }
-        current = record[segment];
-    }
-    const tail = path[path.length - 1];
-    if (Array.isArray(current)) {
-        if (!isIndexSegment(tail)) {
-            return false;
-        }
-        const index = Number.parseInt(tail, 10);
-        if (!Number.isFinite(index) || index < 0 || index >= current.length) {
-            return false;
-        }
-        current.splice(index, 1);
-        return true;
-    }
-    if (!current || typeof current !== "object") {
-        return false;
-    }
-    const record = current;
-    if (!hasOwnKey(record, tail)) {
-        return false;
-    }
-    delete record[tail];
-    return true;
-}