@joshuafolkken/kit 1.872.0

package/dist/config-merge/index.js

@@ -0,0 +1,459 @@
+// scripts/config-merge/list-patch.ts
+function is_matching(entry, matchers) {
+  return matchers.some(
+    (matcher) => typeof matcher === "string" ? matcher === entry : matcher.test(entry)
+  );
+}
+function apply_remove(existing, remove) {
+  if (remove === void 0 || remove.length === 0) return existing;
+  return existing.filter((entry) => !is_matching(entry, remove));
+}
+function collect_additions(kept, ensure) {
+  if (ensure === void 0) return [];
+  return ensure.filter((entry) => !kept.includes(entry));
+}
+function apply_list_patch(existing, patch) {
+  const kept = apply_remove(existing, patch.remove);
+  const additions = collect_additions(kept, patch.ensure);
+  const is_changed = additions.length > 0 || kept.length !== existing.length;
+  return { next: [...additions, ...kept], is_changed };
+}
+var list_patch = {
+  is_matching,
+  apply_list_patch
+};
+
+// scripts/lib/schemas.ts
+import { z } from "zod";
+var overrides_snapshot_schema = z.record(z.string(), z.string());
+var package_version_schema = z.object({ version: z.string() });
+var package_named_version_schema = z.looseObject({ name: z.string(), version: z.string() });
+var package_with_version_schema = z.looseObject({ version: z.string() });
+var ls_global_dependency_schema = z.looseObject({ version: z.string() });
+var ls_global_dependencies_schema = z.record(z.string(), ls_global_dependency_schema).optional();
+var pnpm_ls_global_schema = z.array(
+  z.looseObject({
+    dependencies: ls_global_dependencies_schema
+  })
+);
+var vscode_settings_schema = z.record(z.string(), z.unknown());
+var with_scripts_schema = z.looseObject({
+  scripts: z.record(z.string(), z.string()).optional()
+});
+var with_development_deps_schema = z.looseObject({
+  devDependencies: z.record(z.string(), z.string()).optional()
+});
+var with_package_manager_schema = z.looseObject({
+  packageManager: z.string().optional()
+});
+var with_development_engine_schema = z.looseObject({
+  devEngines: z.record(z.string(), z.unknown()).optional()
+});
+var bin_entry_schema = z.union([z.string(), z.record(z.string(), z.string())]).optional();
+var package_bin_schema = z.looseObject({ bin: bin_entry_schema });
+var json_object_schema = z.record(z.string(), z.unknown());
+var string_array_schema = z.array(z.string());
+var string_record_schema = z.record(z.string(), z.string());
+
+// scripts/config-merge/parse-jsonc.ts
+import strip_json_comments from "strip-json-comments";
+function parse_jsonc(content) {
+  const stripped = strip_json_comments(content, { trailingCommas: true });
+  return json_object_schema.parse(JSON.parse(stripped));
+}
+
+// scripts/config-merge/patch-json-key.ts
+import { createScanner, findNodeAtLocation, getNodeValue, parseTree } from "jsonc-parser";
+import strip_json_comments2 from "strip-json-comments";
+
+// scripts/config-merge/json-format.ts
+var PRINT_WIDTH = 100;
+var TAB_WIDTH = 2;
+var ARRAY_CLOSE = /^\t*\],?$/u;
+function is_array_open(line) {
+  return line.endsWith("[");
+}
+function is_leaf_element(line) {
+  return !line.endsWith("{") && !line.endsWith("[");
+}
+function line_width(line) {
+  const tabs = line.length - line.trimStart().length;
+  return tabs * TAB_WIDTH + (line.length - tabs);
+}
+function flatten_elements(elements) {
+  const scalars = elements.map((line) => line.trim().replace(/,$/u, ""));
+  return `[${scalars.join(", ")}]`;
+}
+function collect_block(lines, start) {
+  const close = lines.findIndex((line, index) => index > start && ARRAY_CLOSE.test(line));
+  if (close === -1) return void 0;
+  const elements = lines.slice(start + 1, close);
+  if (elements.some((line) => !is_leaf_element(line))) return void 0;
+  return { elements, close: lines[close] ?? "", end: close };
+}
+function try_inline(open, block) {
+  const trailing_comma = block.close.trimStart() === "]," ? "," : "";
+  const inlined = `${open.slice(0, -1)}${flatten_elements(block.elements)}${trailing_comma}`;
+  return line_width(inlined) <= PRINT_WIDTH ? inlined : void 0;
+}
+function rewrite_at(lines, index, line) {
+  const verbatim = { lines: [line], next: index + 1 };
+  const block = is_array_open(line) ? collect_block(lines, index) : void 0;
+  if (block === void 0) return verbatim;
+  const inlined = try_inline(line, block);
+  if (inlined === void 0) return verbatim;
+  return { lines: [inlined], next: block.end + 1 };
+}
+function inline_short_arrays(text) {
+  const lines = text.split("\n");
+  const output = [];
+  let index = 0;
+  while (index < lines.length) {
+    const rewrite = rewrite_at(lines, index, lines[index] ?? "");
+    output.push(...rewrite.lines);
+    index = rewrite.next;
+  }
+  return output.join("\n");
+}
+function format_json(value) {
+  return `${inline_short_arrays(JSON.stringify(value, void 0, "	"))}
+`;
+}
+function format_package_json(value) {
+  return `${JSON.stringify(value, void 0, "	")}
+`;
+}
+var json_format = {
+  inline_short_arrays,
+  format_json,
+  format_package_json
+};
+
+// scripts/config-merge/patch-json-key.ts
+var DOCUMENT_SUFFIX = "\n}\n";
+var DEFAULT_INDENT = "	";
+var LEADING_BLANKS = /^[\t ]*/u;
+var PREVIOUS_LINE_OFFSET = 2;
+var CRLF = "\r\n";
+var COMMA_PROBE_VALUE = 0;
+function render_value(key, value, has_trailing_comma) {
+  const probe_key = `${key} `;
+  const probe = has_trailing_comma ? { [key]: value, [probe_key]: COMMA_PROBE_VALUE } : { [key]: value };
+  const document = json_format.format_json(probe);
+  const prefix = `{
+	${JSON.stringify(key)}: `;
+  const suffix = has_trailing_comma ? `,
+	${JSON.stringify(probe_key)}: ${String(COMMA_PROBE_VALUE)}${DOCUMENT_SUFFIX}` : DOCUMENT_SUFFIX;
+  return document.slice(prefix.length, document.length - suffix.length);
+}
+function parse_root(content) {
+  const root = parseTree(content);
+  return root?.type === "object" ? root : void 0;
+}
+function replace_range(content, range, text) {
+  return content.slice(0, range.offset) + text + content.slice(range.offset + range.length);
+}
+function insert_at(content, offset, text) {
+  return replace_range(content, { offset, length: 0 }, text);
+}
+function render_indent(value_text, unit) {
+  if (unit === DEFAULT_INDENT || unit.length === 0) return value_text;
+  return value_text.replaceAll(/^\t+/gmu, (tabs) => unit.repeat(tabs.length));
+}
+function eol_of(content) {
+  return content.includes(CRLF) ? CRLF : "\n";
+}
+function fit_value(content, value_text, indent) {
+  const indented = render_indent(value_text, indent);
+  if (eol_of(content) === "\n") return indented;
+  return indented.split("\n").join(CRLF);
+}
+function line_indent(content, offset) {
+  const line_start = content.lastIndexOf("\n", offset - 1) + 1;
+  return LEADING_BLANKS.exec(content.slice(line_start, offset))?.[0] ?? "";
+}
+function line_end(content, offset) {
+  const index = content.indexOf("\n", offset);
+  if (index === -1) return content.length;
+  return index > offset && content[index - 1] === "\r" ? index - 1 : index;
+}
+function render_property(content, key, value_text, indent) {
+  return `${JSON.stringify(key)}: ${fit_value(content, value_text, indent)}`;
+}
+function insertion_offset(content, root, value_end) {
+  return Math.min(line_end(content, value_end), root.offset + root.length - 1);
+}
+function separator_offset(content, offset, limit) {
+  const scanner = createScanner(content, true);
+  scanner.setPosition(offset);
+  scanner.scan();
+  const at = scanner.getTokenOffset();
+  return at < limit && content[at] === "," ? at : -1;
+}
+function has_separator_after(content, offset, limit) {
+  return separator_offset(content, offset, limit) !== -1;
+}
+function property_key(property) {
+  const key = property.children?.[0]?.value;
+  return typeof key === "string" ? key : void 0;
+}
+function target_value_end(property) {
+  const value_node = property?.children?.[1];
+  return value_node === void 0 ? void 0 : value_node.offset + value_node.length;
+}
+function contains_comment(content, node) {
+  const text = content.slice(node.offset, node.offset + node.length);
+  return strip_json_comments2(text) !== text;
+}
+function rebalanced_value(content, key, value_node, has_trailing_comma) {
+  if (contains_comment(content, value_node)) return void 0;
+  const indent = line_indent(content, value_node.offset);
+  const rendered = fit_value(
+    content,
+    render_value(key, getNodeValue(value_node), has_trailing_comma),
+    indent
+  );
+  const current = content.slice(value_node.offset, value_node.offset + value_node.length);
+  return rendered === current ? void 0 : rendered;
+}
+function rebalance(content, property, has_trailing_comma) {
+  const key = property_key(property);
+  const value_node = property.children?.[1];
+  if (key === void 0 || value_node === void 0) return content;
+  const rendered = rebalanced_value(content, key, value_node, has_trailing_comma);
+  return rendered === void 0 ? content : replace_range(content, value_node, rendered);
+}
+function append_after(content, root, last, property) {
+  const value_end = last.offset + last.length;
+  const closing_brace = root.offset + root.length - 1;
+  const separator = has_separator_after(content, value_end, closing_brace) ? "" : ",";
+  const with_property = insert_at(content, insertion_offset(content, root, value_end), property);
+  return insert_at(with_property, value_end, separator);
+}
+function insert_only_property(content, root, property) {
+  const closing_brace = root.offset + root.length - 1;
+  const lead = content[closing_brace - 1] === "\n" ? "" : eol_of(content);
+  return insert_at(content, closing_brace, `${lead}${DEFAULT_INDENT}${property}${eol_of(content)}`);
+}
+function insert_property(content, root, key, value_text) {
+  const last = root.children?.at(-1);
+  if (last === void 0) {
+    const only = render_property(content, key, value_text, DEFAULT_INDENT);
+    return insert_only_property(content, root, only);
+  }
+  const indent = line_indent(content, last.offset);
+  const property = `${eol_of(content)}${indent}${render_property(content, key, value_text, indent)}`;
+  return rebalance(append_after(content, root, last, property), last, true);
+}
+function end_of_trailing_comment(content, end) {
+  const stop = line_end(content, end);
+  return content.slice(end, stop).trimStart().startsWith("//") ? stop : end;
+}
+function start_of_leading_comments(content, line_start, floor) {
+  let start = line_start;
+  while (start > floor) {
+    const previous = content.lastIndexOf("\n", start - PREVIOUS_LINE_OFFSET) + 1;
+    const is_comment_line = content.slice(previous, start).trimStart().startsWith("//");
+    if (!is_comment_line || previous < floor) return start;
+    start = previous;
+  }
+  return start;
+}
+function end_of_line_break(content, offset) {
+  if (content[offset] === "\r" && content[offset + 1] === "\n") return offset + PREVIOUS_LINE_OFFSET;
+  return content[offset] === "\n" ? offset + 1 : offset;
+}
+function body_range(content, root, target, separator_limit) {
+  const value_end = target.offset + target.length;
+  const comma = separator_limit === -1 ? -1 : separator_offset(content, value_end, separator_limit);
+  const end = end_of_trailing_comment(content, comma === -1 ? value_end : comma + 1);
+  const line_start = content.lastIndexOf("\n", target.offset - 1) + 1;
+  const is_own_line = content.slice(line_start, target.offset).trim().length === 0;
+  if (!is_own_line) return { offset: target.offset, length: end - target.offset };
+  const start = start_of_leading_comments(content, line_start, root.offset + 1);
+  return { offset: start, length: end_of_line_break(content, end) - start };
+}
+function ranges_for_last_property(content, root, previous, target) {
+  const comma = separator_offset(content, previous.offset + previous.length, target.offset);
+  const body = body_range(content, root, target, -1);
+  return comma === -1 ? [body] : [{ offset: comma, length: 1 }, body];
+}
+function removal_ranges(content, root, index) {
+  const children = root.children ?? [];
+  const target = children[index];
+  if (target === void 0) return [];
+  const next = children[index + 1];
+  if (next !== void 0) return [body_range(content, root, target, next.offset)];
+  const previous = children[index - 1];
+  if (previous === void 0) return [{ offset: root.offset, length: root.length }];
+  return ranges_for_last_property(content, root, previous, target);
+}
+function property_index(root, key) {
+  return (root.children ?? []).findIndex((child) => child.children?.[0]?.value === key);
+}
+function with_trailing_newline(content) {
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+function is_followed_by_comma(content, root, key) {
+  const children = root.children ?? [];
+  const index = property_index(root, key);
+  if (index < 0) return false;
+  if (index < children.length - 1) return true;
+  const value_end = target_value_end(children[index]);
+  return value_end !== void 0 && has_separator_after(content, value_end, root.offset + root.length);
+}
+function set_json_key(content, key, value) {
+  const root = parse_root(content);
+  if (root === void 0) return content;
+  const existing = findNodeAtLocation(root, [key]);
+  const value_text = render_value(
+    key,
+    value,
+    existing !== void 0 && is_followed_by_comma(content, root, key)
+  );
+  if (existing === void 0) {
+    return with_trailing_newline(insert_property(content, root, key, value_text));
+  }
+  const indented = fit_value(content, value_text, line_indent(content, existing.offset));
+  return with_trailing_newline(replace_range(content, existing, indented));
+}
+function resolve_parent(content, path) {
+  const root = parse_root(content);
+  if (root === void 0) return void 0;
+  const parent = path.length > 1 ? findNodeAtLocation(root, path.slice(0, -1)) : root;
+  return parent?.type === "object" ? parent : void 0;
+}
+function cut_ranges(content, parent, ranges) {
+  const ordered = ranges.toSorted((left, right) => right.offset - left.offset);
+  let next = content;
+  for (const range of ordered) {
+    next = replace_range(next, range, range.offset === parent.offset ? "{}" : "");
+  }
+  return next;
+}
+function rebalance_new_last(content, path) {
+  const parent = resolve_parent(content, path);
+  const last = parent?.children?.at(-1);
+  if (parent === void 0 || last === void 0) return content;
+  return rebalance(content, last, has_separator_after(content, parent.offset, parent.offset));
+}
+function cut_property(content, parent, path) {
+  const index = property_index(parent, path.at(-1) ?? "");
+  const ranges = removal_ranges(content, parent, index);
+  if (ranges.length === 0) return content;
+  const cut = cut_ranges(content, parent, ranges);
+  const did_end_object = index === (parent.children ?? []).length - 1;
+  return did_end_object ? rebalance_new_last(cut, path) : cut;
+}
+function remove_json_path(content, path) {
+  const parent = resolve_parent(content, path);
+  if (parent === void 0) return content;
+  const next = cut_property(content, parent, path);
+  return next === content ? content : with_trailing_newline(next);
+}
+function remove_json_key(content, key) {
+  return remove_json_path(content, [key]);
+}
+var patch_json_key = {
+  set_json_key,
+  remove_json_key,
+  remove_json_path
+};
+
+// scripts/config-merge/patch-json-list.ts
+function normalize_list(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.map(String);
+  return [];
+}
+function patch_json_list_field(content, options) {
+  const parsed = parse_jsonc(content);
+  const existing = normalize_list(parsed[options.field]);
+  const { next, is_changed } = list_patch.apply_list_patch(existing, options);
+  if (!is_changed) return content;
+  return patch_json_key.set_json_key(content, options.field, [...next]);
+}
+var json_list = {
+  patch_json_list_field
+};
+
+// scripts/yaml/yaml-document.ts
+import { load, loadAll, YAMLException } from "js-yaml";
+var EMPTY_YAML_REASON = "expected a document, but the input is empty";
+function load_yaml_or_empty(content) {
+  try {
+    return load(content);
+  } catch (error) {
+    if (error instanceof YAMLException && error.reason === EMPTY_YAML_REASON) return {};
+    throw error;
+  }
+}
+function parse_yaml(content) {
+  const raw = load_yaml_or_empty(content);
+  if (raw === null || raw === void 0) return {};
+  return json_object_schema.parse(raw);
+}
+function is_mapping_document(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse_yaml_documents(content) {
+  if (content.trim().length === 0) return [];
+  return loadAll(content).filter(is_mapping_document);
+}
+var yaml_document = { is_mapping_document, parse_yaml, parse_yaml_documents };
+
+// scripts/config-merge/patch-yaml-list.ts
+import { dump } from "js-yaml";
+var { parse_yaml: parse_yaml2 } = yaml_document;
+function read_yaml_list_field(content, field) {
+  const raw = parse_yaml2(content)[field];
+  if (typeof raw === "string") return [raw];
+  return Array.isArray(raw) ? string_array_schema.parse(raw) : [];
+}
+function replace_field(parsed, field, value) {
+  return Object.fromEntries(
+    Object.entries(parsed).map(([key, entry]) => [key, key === field ? [...value] : entry])
+  );
+}
+function insert_after(parsed, field, value, anchor) {
+  const entries = Object.entries(parsed);
+  const index = entries.findIndex(([key]) => key === anchor);
+  if (index === -1) return { ...parsed, [field]: [...value] };
+  return Object.fromEntries([
+    ...entries.slice(0, index + 1),
+    [field, [...value]],
+    ...entries.slice(index + 1)
+  ]);
+}
+function insert_new_field(parsed, field, value, position) {
+  if (position === "front") return { [field]: [...value], ...parsed };
+  if (position === "end") return { ...parsed, [field]: [...value] };
+  return insert_after(parsed, field, value, position.after);
+}
+function place_field(parsed, field, value, position) {
+  if (Object.hasOwn(parsed, field)) return replace_field(parsed, field, value);
+  return insert_new_field(parsed, field, value, position);
+}
+function patch_yaml_list_field(content, options) {
+  const parsed = parse_yaml2(content);
+  const existing = read_yaml_list_field(content, options.field);
+  const { next, is_changed } = list_patch.apply_list_patch(existing, options);
+  if (!is_changed) return content;
+  const placed = place_field(parsed, options.field, next, options.position ?? "front");
+  return dump(placed, options.quote_style === void 0 ? {} : { quoteStyle: options.quote_style });
+}
+var yaml_list = {
+  patch_yaml_list_field,
+  read_yaml_list_field
+};
+
+// scripts/config-merge/index.ts
+var config_merge = {
+  patch_yaml_list_field: yaml_list.patch_yaml_list_field,
+  read_yaml_list_field: yaml_list.read_yaml_list_field,
+  patch_json_list_field: json_list.patch_json_list_field
+};
+export {
+  config_merge
+};

package/dist/hooks/batch-guard.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env tsx
+import {
+  DISABLED_VALUES,
+  SWITCH_ENV_KEY,
+  batch_outcome,
+  batch_refusal,
+  deny_envelope,
+  is_enabled,
+  load_environment_file,
+  notice_refusal_path,
+  refusal_path
+} from "./chunk-B2LIXYFL.js";
+import "./chunk-B4YNCUGB.js";
+import "./chunk-GXKKK23T.js";
+import "./chunk-KABG6AEW.js";
+import "./chunk-FXAKJKTB.js";
+import "./chunk-SSX23SJ2.js";
+export {
+  DISABLED_VALUES,
+  SWITCH_ENV_KEY,
+  batch_outcome,
+  batch_refusal,
+  deny_envelope,
+  is_enabled,
+  load_environment_file,
+  notice_refusal_path,
+  refusal_path
+};