@wangyaoshen/remux 0.3.8-dev.29e114b

package/pty-daemon.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/pty-daemon.ts
+import net from "net";
+import pty from "node-pty";
+import { parseArgs } from "util";
+var TAG_PTY_OUTPUT = 1;
+var TAG_CLIENT_INPUT = 2;
+var TAG_RESIZE = 3;
+var TAG_STATUS_REQ = 4;
+var TAG_STATUS_RES = 5;
+var TAG_SNAPSHOT_REQ = 6;
+var TAG_SNAPSHOT_RES = 7;
+var TAG_SCROLLBACK_REQ = 8;
+var TAG_SCROLLBACK_RES = 9;
+var TAG_SHUTDOWN = 255;
+function encodeFrame(tag, payload) {
+  const data = typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
+  const frame = Buffer.alloc(5 + data.length);
+  frame[0] = tag;
+  frame.writeUInt32BE(data.length, 1);
+  data.copy(frame, 5);
+  return frame;
+}
+var FrameParser = class {
+  buffer = Buffer.alloc(0);
+  onFrame;
+  constructor(onFrame) {
+    this.onFrame = onFrame;
+  }
+  feed(data) {
+    this.buffer = Buffer.concat([this.buffer, data]);
+    while (this.buffer.length >= 5) {
+      const tag = this.buffer[0];
+      const length = this.buffer.readUInt32BE(1);
+      if (this.buffer.length < 5 + length) break;
+      const payload = this.buffer.subarray(5, 5 + length);
+      this.buffer = this.buffer.subarray(5 + length);
+      this.onFrame(tag, payload);
+    }
+  }
+};
+var RingBuffer = class {
+  buf;
+  maxBytes;
+  writePos;
+  length;
+  constructor(maxBytes = 10 * 1024 * 1024) {
+    this.buf = Buffer.alloc(maxBytes);
+    this.maxBytes = maxBytes;
+    this.writePos = 0;
+    this.length = 0;
+  }
+  write(data) {
+    const bytes = typeof data === "string" ? Buffer.from(data) : data;
+    if (bytes.length >= this.maxBytes) {
+      bytes.copy(this.buf, 0, bytes.length - this.maxBytes);
+      this.writePos = 0;
+      this.length = this.maxBytes;
+      return;
+    }
+    const space = this.maxBytes - this.writePos;
+    if (bytes.length <= space) {
+      bytes.copy(this.buf, this.writePos);
+    } else {
+      bytes.copy(this.buf, this.writePos, 0, space);
+      bytes.copy(this.buf, 0, space);
+    }
+    this.writePos = (this.writePos + bytes.length) % this.maxBytes;
+    this.length = Math.min(this.length + bytes.length, this.maxBytes);
+  }
+  read() {
+    if (this.length === 0) return Buffer.alloc(0);
+    if (this.length < this.maxBytes) {
+      return Buffer.from(this.buf.subarray(this.writePos - this.length, this.writePos));
+    }
+    return Buffer.concat([
+      this.buf.subarray(this.writePos),
+      this.buf.subarray(0, this.writePos)
+    ]);
+  }
+};
+function parseCliArgs() {
+  const { values } = parseArgs({
+    options: {
+      socket: { type: "string" },
+      shell: { type: "string" },
+      cols: { type: "string" },
+      rows: { type: "string" },
+      cwd: { type: "string" },
+      "tab-id": { type: "string" }
+    },
+    strict: true
+  });
+  if (!values.socket || !values.shell) {
+    console.error("Usage: pty-daemon --socket <path> --shell <shell> [--cols N] [--rows N] [--cwd dir] [--tab-id id]");
+    process.exit(1);
+  }
+  return {
+    socket: values.socket,
+    shell: values.shell,
+    cols: parseInt(values.cols || "80", 10),
+    rows: parseInt(values.rows || "24", 10),
+    cwd: values.cwd || process.env.HOME || "/",
+    tabId: values["tab-id"] || "0"
+  };
+}
+function main() {
+  const args = parseCliArgs();
+  let seq = 0;
+  if (typeof process.disconnect === "function") {
+    try {
+      process.disconnect();
+    } catch {
+    }
+  }
+  const ptyProcess = pty.spawn(args.shell, [], {
+    name: "xterm-256color",
+    cols: args.cols,
+    rows: args.rows,
+    cwd: args.cwd,
+    env: {
+      ...process.env,
+      TERM: "xterm-256color",
+      COLORTERM: "truecolor"
+    }
+  });
+  const scrollback = new RingBuffer();
+  const clients = /* @__PURE__ */ new Set();
+  let alive = true;
+  console.log(`[pty-daemon] started: pid=${ptyProcess.pid} socket=${args.socket} tab-id=${args.tabId}`);
+  ptyProcess.onData((data) => {
+    seq++;
+    scrollback.write(data);
+    const frame = encodeFrame(TAG_PTY_OUTPUT, data);
+    for (const client of clients) {
+      try {
+        client.write(frame);
+      } catch {
+      }
+    }
+  });
+  ptyProcess.onExit(({ exitCode }) => {
+    alive = false;
+    console.log(`[pty-daemon] PTY exited: code=${exitCode} tab-id=${args.tabId}`);
+    const exitMsg = `\r
+\x1B[33mShell exited (code: ${exitCode})\x1B[0m\r
+`;
+    const frame = encodeFrame(TAG_PTY_OUTPUT, exitMsg);
+    for (const client of clients) {
+      try {
+        client.write(frame);
+      } catch {
+      }
+    }
+    setTimeout(() => {
+      for (const client of clients) {
+        try {
+          client.end();
+        } catch {
+        }
+      }
+      cleanup();
+    }, 2e3);
+  });
+  const server = net.createServer((socket) => {
+    clients.add(socket);
+    console.log(`[pty-daemon] client connected (total: ${clients.size})`);
+    const parser = new FrameParser((tag, payload) => {
+      switch (tag) {
+        case TAG_CLIENT_INPUT:
+          if (alive) {
+            ptyProcess.write(payload.toString("utf8"));
+          }
+          break;
+        case TAG_RESIZE: {
+          try {
+            const { cols, rows } = JSON.parse(payload.toString("utf8"));
+            if (alive && cols > 0 && rows > 0) {
+              ptyProcess.resize(
+                Math.max(1, Math.min(cols, 500)),
+                Math.max(1, Math.min(rows, 200))
+              );
+            }
+          } catch {
+          }
+          break;
+        }
+        case TAG_STATUS_REQ: {
+          const status = JSON.stringify({
+            pid: ptyProcess.pid,
+            cols: args.cols,
+            rows: args.rows,
+            alive,
+            cwd: args.cwd,
+            tabId: args.tabId,
+            seq
+          });
+          socket.write(encodeFrame(TAG_STATUS_RES, status));
+          break;
+        }
+        case TAG_SNAPSHOT_REQ: {
+          const data = scrollback.read();
+          socket.write(encodeFrame(TAG_SNAPSHOT_RES, data));
+          break;
+        }
+        case TAG_SCROLLBACK_REQ: {
+          const data = scrollback.read();
+          socket.write(encodeFrame(TAG_SCROLLBACK_RES, data));
+          break;
+        }
+        case TAG_SHUTDOWN:
+          console.log(`[pty-daemon] shutdown requested`);
+          if (alive) {
+            try {
+              ptyProcess.kill();
+            } catch {
+            }
+          }
+          for (const c of clients) {
+            try {
+              c.end();
+            } catch {
+            }
+          }
+          cleanup();
+          break;
+      }
+    });
+    socket.on("data", (data) => {
+      parser.feed(Buffer.isBuffer(data) ? data : Buffer.from(data));
+    });
+    socket.on("close", () => {
+      clients.delete(socket);
+      console.log(`[pty-daemon] client disconnected (total: ${clients.size})`);
+    });
+    socket.on("error", (err) => {
+      console.error(`[pty-daemon] client socket error:`, err.message);
+      clients.delete(socket);
+    });
+  });
+  try {
+    const fs = __require("fs");
+    if (fs.existsSync(args.socket)) {
+      fs.unlinkSync(args.socket);
+    }
+  } catch {
+  }
+  server.listen(args.socket, () => {
+    console.log(`[pty-daemon] listening on ${args.socket}`);
+  });
+  server.on("error", (err) => {
+    console.error(`[pty-daemon] server error:`, err.message);
+    cleanup();
+  });
+  function cleanup() {
+    try {
+      const fs = __require("fs");
+      if (fs.existsSync(args.socket)) {
+        fs.unlinkSync(args.socket);
+      }
+    } catch {
+    }
+    server.close();
+    process.exit(0);
+  }
+  process.on("SIGTERM", () => {
+    console.log(`[pty-daemon] SIGTERM received`);
+    if (alive) {
+      try {
+        ptyProcess.kill();
+      } catch {
+      }
+    }
+    cleanup();
+  });
+  process.on("SIGINT", () => {
+  });
+}
+var isMainEntry = process.argv[1]?.includes("pty-daemon") || process.argv.includes("--socket");
+if (isMainEntry) {
+  main();
+}
+export {
+  FrameParser,
+  TAG_CLIENT_INPUT,
+  TAG_PTY_OUTPUT,
+  TAG_RESIZE,
+  TAG_SCROLLBACK_REQ,
+  TAG_SCROLLBACK_RES,
+  TAG_SHUTDOWN,
+  TAG_SNAPSHOT_REQ,
+  TAG_SNAPSHOT_RES,
+  TAG_STATUS_REQ,
+  TAG_STATUS_RES,
+  encodeFrame
+};

package/release-please-config.json

@@ -0,0 +1,14 @@
+{
+  "packages": {
+    ".": {
+      "release-type": "node",
+      "changelog-sections": [
+        { "type": "feat", "section": "Features" },
+        { "type": "fix", "section": "Bug Fixes" },
+        { "type": "chore", "section": "Miscellaneous" },
+        { "type": "refactor", "section": "Refactoring" },
+        { "type": "docs", "section": "Documentation" }
+      ]
+    }
+  }
+}

package/scripts/auto-deploy.sh

@@ -0,0 +1,46 @@
+#!/bin/bash
+# Auto-deploy script for Remux runtime instances.
+# Usage: auto-deploy.sh <branch> <worktree-path> <launchd-label>
+#
+# Checks if origin/<branch> has new commits, pulls, installs deps, and restarts.
+# Designed to be called by launchd on a schedule (e.g. every 2 minutes).
+
+set -euo pipefail
+
+BRANCH="${1:?Usage: auto-deploy.sh <branch> <worktree-path> <launchd-label>}"
+WORKTREE="${2:?}"
+LABEL="${3:?}"
+LOG_PREFIX="[deploy:${BRANCH}]"
+
+cd "$WORKTREE" || { echo "$LOG_PREFIX worktree not found: $WORKTREE"; exit 1; }
+
+# Fetch latest from origin
+git fetch origin "$BRANCH" --quiet 2>/dev/null || { echo "$LOG_PREFIX fetch failed"; exit 1; }
+
+LOCAL=$(git rev-parse HEAD 2>/dev/null)
+REMOTE=$(git rev-parse "origin/${BRANCH}" 2>/dev/null)
+
+if [ "$LOCAL" = "$REMOTE" ]; then
+  # Already up to date
+  exit 0
+fi
+
+echo "$LOG_PREFIX updating ${LOCAL:0:7} → ${REMOTE:0:7}"
+
+# Pull changes
+git checkout --detach "origin/${BRANCH}" --quiet 2>/dev/null
+
+# Install dependencies if lockfile changed
+if ! git diff --quiet "$LOCAL" "$REMOTE" -- pnpm-lock.yaml 2>/dev/null; then
+  echo "$LOG_PREFIX pnpm-lock.yaml changed, installing deps"
+  /opt/homebrew/bin/pnpm install --frozen-lockfile --prefer-offline 2>/dev/null || true
+fi
+
+# Fix node-pty spawn-helper permissions (needed after fresh install)
+find node_modules -name "spawn-helper" -type f -exec chmod +x {} \; 2>/dev/null || true
+
+# Restart the service
+echo "$LOG_PREFIX restarting $LABEL"
+/bin/launchctl kickstart -k "gui/501/${LABEL}" 2>/dev/null || true
+
+echo "$LOG_PREFIX deployed ${REMOTE:0:7}"

package/scripts/build-dmg.sh

@@ -0,0 +1,121 @@
+#!/bin/bash
+# Build Remux.app and create a DMG installer.
+# Usage: ./scripts/build-dmg.sh [--version X.Y.Z]
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+APP_DIR="$ROOT_DIR/apps/macos"
+BUILD_DIR="$ROOT_DIR/build"
+
+# Read version from package.json or CLI arg
+VERSION="${1:-}"
+if [ -z "$VERSION" ]; then
+  VERSION=$(node -p "require('$ROOT_DIR/package.json').version" 2>/dev/null || echo "0.0.0")
+fi
+# Strip leading 'v' if present
+VERSION="${VERSION#v}"
+
+echo "Building Remux.app v${VERSION}..."
+
+# Step 1: Build ghostty xcframework if missing
+XCFW="$ROOT_DIR/vendor/ghostty/macos/GhosttyKit.xcframework"
+if [ ! -d "$XCFW" ] || [ ! -f "$XCFW/Info.plist" ]; then
+  echo "GhosttyKit.xcframework not found. Building from source..."
+  cd "$ROOT_DIR/vendor/ghostty"
+  git submodule update --init 2>/dev/null || true
+  zig build -Demit-xcframework=true -Dxcframework-target=native -Doptimize=ReleaseFast
+  echo "GhosttyKit built."
+fi
+
+# Step 2: Build macOS app (release)
+cd "$APP_DIR"
+swift build -c release 2>&1
+
+BINARY=$(swift build -c release --show-bin-path)/Remux
+if [ ! -f "$BINARY" ]; then
+  echo "Error: Binary not found at $BINARY"
+  exit 1
+fi
+
+# Step 3: Create .app bundle
+rm -rf "$BUILD_DIR/Remux.app"
+mkdir -p "$BUILD_DIR/Remux.app/Contents/MacOS"
+mkdir -p "$BUILD_DIR/Remux.app/Contents/Resources"
+
+cp "$BINARY" "$BUILD_DIR/Remux.app/Contents/MacOS/Remux"
+
+# Copy ghostty resources if available
+if [ -d "$APP_DIR/Resources/terminfo" ]; then
+  cp -r "$APP_DIR/Resources/terminfo" "$BUILD_DIR/Remux.app/Contents/Resources/"
+fi
+if [ -d "$APP_DIR/Resources/shell-integration" ]; then
+  cp -r "$APP_DIR/Resources/shell-integration" "$BUILD_DIR/Remux.app/Contents/Resources/"
+fi
+
+cat > "$BUILD_DIR/Remux.app/Contents/Info.plist" << PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleName</key>
+    <string>Remux</string>
+    <key>CFBundleDisplayName</key>
+    <string>Remux</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.remux.desktop</string>
+    <key>CFBundleVersion</key>
+    <string>${VERSION}</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${VERSION}</string>
+    <key>CFBundleExecutable</key>
+    <string>Remux</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>14.0</string>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+    <key>LSUIElement</key>
+    <false/>
+    <key>NSPrincipalClass</key>
+    <string>NSApplication</string>
+</dict>
+</plist>
+PLIST
+
+echo "✓ Remux.app created at $BUILD_DIR/Remux.app"
+
+# Step 4: Create DMG
+DMG_NAME="Remux-${VERSION}-arm64.dmg"
+rm -f "$BUILD_DIR/$DMG_NAME"
+
+if command -v create-dmg &> /dev/null; then
+  echo "Creating DMG with create-dmg..."
+  create-dmg \
+    --volname "Remux" \
+    --window-pos 200 120 \
+    --window-size 600 400 \
+    --icon-size 100 \
+    --icon "Remux.app" 150 190 \
+    --app-drop-link 450 190 \
+    "$BUILD_DIR/$DMG_NAME" \
+    "$BUILD_DIR/Remux.app" \
+    2>/dev/null || true
+else
+  # Fallback: simple hdiutil DMG
+  echo "Creating DMG with hdiutil..."
+  hdiutil create -volname "Remux" \
+    -srcfolder "$BUILD_DIR/Remux.app" \
+    -ov -format UDZO \
+    "$BUILD_DIR/$DMG_NAME"
+fi
+
+if [ -f "$BUILD_DIR/$DMG_NAME" ]; then
+  SIZE=$(du -h "$BUILD_DIR/$DMG_NAME" | cut -f1)
+  echo "✓ DMG created: $BUILD_DIR/$DMG_NAME ($SIZE)"
+else
+  echo "⚠ DMG creation failed, but Remux.app is available"
+fi

package/scripts/build-ghostty-kit.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Build GhosttyKit.xcframework from the ghostty submodule.
+# Prerequisites: zig (brew install zig), Xcode Command Line Tools
+# Usage: ./scripts/build-ghostty-kit.sh [--debug]
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+GHOSTTY_DIR="$ROOT_DIR/vendor/ghostty"
+
+if [ ! -f "$GHOSTTY_DIR/build.zig" ]; then
+    echo "Error: ghostty submodule not found at $GHOSTTY_DIR"
+    echo "Run: git submodule update --init vendor/ghostty"
+    exit 1
+fi
+
+if ! command -v zig &> /dev/null; then
+    echo "Error: zig not found. Install with: brew install zig"
+    exit 1
+fi
+
+OPTIMIZE="ReleaseFast"
+if [ "${1:-}" = "--debug" ]; then
+    OPTIMIZE="Debug"
+fi
+
+echo "Building GhosttyKit.xcframework (optimize=$OPTIMIZE)..."
+cd "$GHOSTTY_DIR"
+zig build -Demit-xcframework=true -Doptimize="$OPTIMIZE"
+
+# Check output — ghostty emits to macos/GhosttyKit.xcframework
+XCFW_PATH="$GHOSTTY_DIR/macos/GhosttyKit.xcframework"
+if [ -d "$XCFW_PATH" ]; then
+    echo "Success: $XCFW_PATH"
+    echo "Size: $(du -sh "$XCFW_PATH" | cut -f1)"
+else
+    echo "Error: xcframework not found at expected path"
+    echo "Checking macos/ and zig-out/ contents:"
+    ls -la "$GHOSTTY_DIR/macos/" 2>/dev/null || echo "macos/ not found"
+    ls -la "$GHOSTTY_DIR/zig-out/" 2>/dev/null || echo "zig-out/ not found"
+    exit 1
+fi

package/scripts/check-active-terminology.mjs

@@ -0,0 +1,132 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+
+const root = process.cwd();
+const entrypoints = ["README.md", "AGENTS.md", "docs", "src", "tests", ".github"];
+const ignoredDirNames = new Set(["node_modules", "dist", ".git", "coverage"]);
+const allowedExtensions = new Set([".md", ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ".yml", ".yaml"]);
+const allowedFiles = new Map([
+  ["docs/ACTIVE_DOCS_INDEX.md", "active index must point to the archived runtime-v2 document set by its real path"],
+  ["docs/adr/ADR_TERMINOLOGY.md", "terminology ADR must name the banned product term explicitly"],
+  ["docs/remux-master-plan-2026-v2.md", "current planning document compares legacy assumptions against the current baseline"],
+  ["docs/LEGACY_PLAN_GAPS.md", "legacy gap ledger must name the invalidated assumptions"],
+  ["docs/TERMINOLOGY_AUDIT.md", "audit output must record the archived terms it scanned"],
+]);
+const archivedRuntimePatterns = [
+  { label: "runtime-v2", regex: /\bruntime-v2\b/i },
+  { label: "remuxd", regex: /\bremuxd\b/i },
+  { label: "old runtime", regex: /\bold runtime\b/i },
+  { label: "daemon", regex: /\bdaemon\b/i },
+];
+const productScrollPattern = /\bscroll\b/i;
+const allowedScrollLinePatterns = [
+  /\bscrollback\b/i,
+  /\bscrollbar\b/i,
+  /\boverscroll\b/i,
+  /\bscrolling\b/i,
+  /\bscrollable\b/i,
+  /\bscrolltoline\b/i,
+  /\bxterm-scrollable-element\b/i,
+  /scroll-snap/i,
+  /-webkit-overflow-scrolling/i,
+  /addEventListener\(\s*["']scroll["']/,
+  /removeEventListener\(\s*["']scroll["']/,
+  /new Event\(\s*["']scroll["']/,
+  /\bscroll fixes\b/i,
+];
+
+async function collectFiles(relativePath) {
+  const absolutePath = path.join(root, relativePath);
+  const stats = await readdir(absolutePath, { withFileTypes: true }).catch(() => null);
+  if (stats === null) {
+    return [relativePath];
+  }
+
+  const files = [];
+  for (const entry of stats) {
+    if (ignoredDirNames.has(entry.name)) {
+      continue;
+    }
+
+    const nextRelative = path.posix.join(relativePath, entry.name);
+    if (nextRelative.startsWith("docs/archive/") || nextRelative.startsWith("docs/assets/")) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      files.push(...(await collectFiles(nextRelative)));
+      continue;
+    }
+
+    if (allowedExtensions.has(path.extname(entry.name))) {
+      files.push(nextRelative);
+    }
+  }
+
+  return files;
+}
+
+async function main() {
+  const files = [];
+  for (const entrypoint of entrypoints) {
+    const absolute = path.join(root, entrypoint);
+    const isDirectory = await readdir(absolute, { withFileTypes: true }).then(() => true).catch(() => false);
+    if (isDirectory) {
+      files.push(...(await collectFiles(entrypoint)));
+      continue;
+    }
+
+    files.push(entrypoint);
+  }
+
+  const violations = [];
+  for (const relativePath of files) {
+    if (allowedFiles.has(relativePath)) {
+      continue;
+    }
+
+    const source = await readFile(path.join(root, relativePath), "utf8");
+    const matchedLabels = archivedRuntimePatterns
+      .filter(({ regex }) => regex.test(source))
+      .map(({ label }) => label);
+
+    const lines = source.split("\n");
+    for (const [index, line] of lines.entries()) {
+      if (!productScrollPattern.test(line)) {
+        continue;
+      }
+
+      if (allowedScrollLinePatterns.some((regex) => regex.test(line))) {
+        continue;
+      }
+
+      matchedLabels.push(`scroll(product-term)@L${index + 1}`);
+    }
+
+    if (matchedLabels.length > 0) {
+      violations.push({ relativePath, matchedLabels });
+    }
+  }
+
+  if (violations.length === 0) {
+    console.log("Terminology guard passed.");
+    return;
+  }
+
+  console.error("Archived-runtime terminology found in active files:");
+  for (const violation of violations) {
+    console.error(`- ${violation.relativePath}: ${violation.matchedLabels.join(", ")}`);
+  }
+
+  console.error("\nAllowed exceptions:");
+  for (const [relativePath, reason] of allowedFiles.entries()) {
+    console.error(`- ${relativePath}: ${reason}`);
+  }
+
+  process.exit(1);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});