@larablox/monolog 0.1.0 → 0.2.0

package/out/Monolog/Handler/FormattableHandlerInterface.luau

@@ -0,0 +1,36 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Handler\FormattableHandlerInterface`.
+	 *
+	 * Upstream pairs this with `FormattableHandlerTrait`; Luau has no traits, so
+	 * implementers carry the `$formatter` field and `getDefaultFormatter()`
+	 * themselves -- see `AbstractProcessingHandler`.
+	 
+]]
+--[[
+	*
+	 * True when the given value implements `FormattableHandlerInterface`.
+	 *
+	 * PHP checks this with `instanceof`; there is no `instanceof` for an
+	 * interface here, so this checks structurally for the two callable members,
+	 * exactly as `isResettable()` (`ResettableInterface.ts`) already does.
+	 
+]]
+local function isFormattable(value)
+	local _value = value
+	if not (type(_value) == "table") then
+		return false
+	end
+	local candidate = value
+	local _setFormatter = candidate.setFormatter
+	local _condition = type(_setFormatter) == "function"
+	if _condition then
+		local _getFormatter = candidate.getFormatter
+		_condition = type(_getFormatter) == "function"
+	end
+	return _condition
+end
+return {
+	isFormattable = isFormattable,
+}

package/out/Monolog/Handler/GroupHandler.d.ts

@@ -0,0 +1,49 @@
+import { Handler } from "./Handler";
+import type { FormatterInterface } from "../Formatter/FormatterInterface";
+import type { HandlerInterface } from "./HandlerInterface";
+import type { LogRecord } from "../LogRecord";
+import type { Processor } from "../Processor/ProcessorInterface";
+import type { ProcessableHandlerInterface } from "./ProcessableHandlerInterface";
+import type { ResettableInterface } from "../ResettableInterface";
+/**
+ * PHP: `Monolog\Handler\GroupHandler`. Forwards records to multiple handlers.
+ *
+ * Upstream gets its processor stack from `ProcessableHandlerTrait`; Luau has
+ * no traits, so the trait's members (`processors`, `processRecord()`,
+ * `resetProcessors()`, `pushProcessor()`, `popProcessor()`) are spelled out
+ * here, the same way `AbstractProcessingHandler` already folds it in.
+ */
+export declare class GroupHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface {
+    protected processors: Processor[];
+    protected handlers: Array<HandlerInterface>;
+    protected bubble: boolean;
+    /**
+     * Upstream's `\InvalidArgumentException` for a non-handler in the array is
+     * kept rather than dropped: it is `GroupHandler`'s own explicit check, not
+     * PHP's parameter type-check, and this port is consumed from plain Luau
+     * too, where TypeScript's `Array<HandlerInterface>` proves nothing. There
+     * is no exception class hierarchy on this platform, so it is a plain
+     * `error()` carrying upstream's message.
+     */
+    constructor(handlers: Array<HandlerInterface>, bubble?: boolean);
+    /** Checks whether any of the grouped handlers will handle the record. */
+    isHandling(record: LogRecord): boolean;
+    /** Handles a record, forwarding a clone of it to every grouped handler. */
+    handle(record: LogRecord): boolean;
+    /** Handles a set of records at once. */
+    handleBatch(records: Array<LogRecord>): void;
+    /** Adds a processor in the stack. */
+    pushProcessor(processor: Processor): this;
+    /** Removes the processor on top of the stack and returns it. */
+    popProcessor(): Processor | undefined;
+    /** Processes a record. */
+    protected processRecord(record: LogRecord): LogRecord;
+    /** Resets any processors on this handler that support resetting. */
+    protected resetProcessors(): void;
+    /** Resets this handler's processors and every grouped handler. */
+    reset(): void;
+    /** Closes every grouped handler. */
+    close(): void;
+    /** Sets the formatter on every grouped handler that supports one. */
+    setFormatter(formatter: FormatterInterface): this;
+}

package/out/Monolog/Handler/GroupHandler.luau

@@ -0,0 +1,139 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Handler = TS.import(script, script.Parent, "Handler").Handler
+local isFormattable = TS.import(script, script.Parent, "FormattableHandlerInterface").isFormattable
+local isHandler = TS.import(script, script.Parent, "HandlerInterface").isHandler
+local isResettable = TS.import(script, script.Parent.Parent, "ResettableInterface").isResettable
+local runProcessor = TS.import(script, script.Parent.Parent, "Processor", "ProcessorInterface").runProcessor
+--[[
+	*
+	 * PHP: `Monolog\Handler\GroupHandler`. Forwards records to multiple handlers.
+	 *
+	 * Upstream gets its processor stack from `ProcessableHandlerTrait`; Luau has
+	 * no traits, so the trait's members (`processors`, `processRecord()`,
+	 * `resetProcessors()`, `pushProcessor()`, `popProcessor()`) are spelled out
+	 * here, the same way `AbstractProcessingHandler` already folds it in.
+	 
+]]
+local GroupHandler
+do
+	local super = Handler
+	GroupHandler = setmetatable({}, {
+		__tostring = function()
+			return "GroupHandler"
+		end,
+		__index = super,
+	})
+	GroupHandler.__index = GroupHandler
+	function GroupHandler.new(...)
+		local self = setmetatable({}, GroupHandler)
+		return self:constructor(...) or self
+	end
+	function GroupHandler:constructor(handlers, bubble)
+		if bubble == nil then
+			bubble = true
+		end
+		super.constructor(self)
+		self.processors = {}
+		for _, handler in handlers do
+			if not isHandler(handler) then
+				error("The first argument of the GroupHandler must be an array of HandlerInterface instances.")
+			end
+		end
+		self.handlers = handlers
+		self.bubble = bubble
+	end
+	function GroupHandler:isHandling(record)
+		for _, handler in self.handlers do
+			if handler:isHandling(record) then
+				return true
+			end
+		end
+		return false
+	end
+	function GroupHandler:handle(record)
+		local processed = record
+		if not (#self.processors == 0) then
+			processed = self:processRecord(processed)
+		end
+		for _, handler in self.handlers do
+			handler:handle(processed:clone())
+		end
+		return self.bubble == false
+	end
+	function GroupHandler:handleBatch(records)
+		local batch = records
+		if not (#self.processors == 0) then
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#records)
+			local _callback = function(record)
+				return self:processRecord(record)
+			end
+			for _k, _v in records do
+				_newValue[_k] = _callback(_v, _k - 1, records)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			batch = _newValue
+		end
+		for _, handler in self.handlers do
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#batch)
+			local _callback = function(record)
+				return record:clone()
+			end
+			for _k, _v in batch do
+				_newValue[_k] = _callback(_v, _k - 1, batch)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			handler:handleBatch(_newValue)
+		end
+	end
+	function GroupHandler:pushProcessor(processor)
+		local _processors = self.processors
+		local _processor = processor
+		table.insert(_processors, 1, _processor)
+		return self
+	end
+	function GroupHandler:popProcessor()
+		return table.remove(self.processors, 1)
+	end
+	function GroupHandler:processRecord(record)
+		local processed = record
+		for _, processor in self.processors do
+			processed = runProcessor(processor, processed)
+		end
+		return processed
+	end
+	function GroupHandler:resetProcessors()
+		for _, processor in self.processors do
+			if isResettable(processor) then
+				processor:reset()
+			end
+		end
+	end
+	function GroupHandler:reset()
+		self:resetProcessors()
+		for _, handler in self.handlers do
+			if isResettable(handler) then
+				handler:reset()
+			end
+		end
+	end
+	function GroupHandler:close()
+		super.close(self)
+		for _, handler in self.handlers do
+			handler:close()
+		end
+	end
+	function GroupHandler:setFormatter(formatter)
+		for _, handler in self.handlers do
+			if isFormattable(handler) then
+				handler:setFormatter(formatter)
+			end
+		end
+		return self
+	end
+end
+return {
+	GroupHandler = GroupHandler,
+}

package/out/Monolog/Handler/HandlerInterface.d.ts

@@ -10,3 +10,13 @@ export interface HandlerInterface {
     /** Closes the handler. */
     close(): void;
 }
+/**
+ * True when the given value implements `HandlerInterface`.
+ *
+ * PHP checks this with `instanceof` -- `GroupHandler`'s constructor and
+ * `FingersCrossedHandler::getHandler()` both reject a non-handler at runtime.
+ * There is no `instanceof` for an interface here, so this checks structurally
+ * for the four callable members, as `isResettable()`
+ * (`ResettableInterface.ts`) already does for its own interface.
+ */
+export declare function isHandler(value: unknown): value is HandlerInterface;

package/out/Monolog/Handler/HandlerInterface.luau

@@ -1,3 +1,38 @@
 -- Compiled with roblox-ts v3.0.0
 --* PHP: `Monolog\Handler\HandlerInterface`. 
-return nil
+--[[
+	*
+	 * True when the given value implements `HandlerInterface`.
+	 *
+	 * PHP checks this with `instanceof` -- `GroupHandler`'s constructor and
+	 * `FingersCrossedHandler::getHandler()` both reject a non-handler at runtime.
+	 * There is no `instanceof` for an interface here, so this checks structurally
+	 * for the four callable members, as `isResettable()`
+	 * (`ResettableInterface.ts`) already does for its own interface.
+	 
+]]
+local function isHandler(value)
+	local _value = value
+	if not (type(_value) == "table") then
+		return false
+	end
+	local candidate = value
+	local _isHandling = candidate.isHandling
+	local _condition = type(_isHandling) == "function"
+	if _condition then
+		local _handle = candidate.handle
+		_condition = type(_handle) == "function"
+		if _condition then
+			local _handleBatch = candidate.handleBatch
+			_condition = type(_handleBatch) == "function"
+			if _condition then
+				local _close = candidate.close
+				_condition = type(_close) == "function"
+			end
+		end
+	end
+	return _condition
+end
+return {
+	isHandler = isHandler,
+}

package/out/Monolog/Handler/ProcessableHandlerInterface.d.ts

@@ -0,0 +1,26 @@
+import type { HandlerInterface } from "./HandlerInterface";
+import type { Processor } from "../Processor/ProcessorInterface";
+/**
+ * PHP: `Monolog\Handler\ProcessableHandlerInterface`.
+ *
+ * Upstream pairs this with `ProcessableHandlerTrait`, which carries the
+ * `$processors` stack and the `processRecord()`/`resetProcessors()` helpers.
+ * Luau has no traits, so every implementer in this port spells those members
+ * out itself -- `AbstractProcessingHandler`, `GroupHandler` and
+ * `FingersCrossedHandler` each carry their own copy, the same way
+ * `AbstractProcessingHandler` already folded the trait in before this
+ * interface existed.
+ */
+export interface ProcessableHandlerInterface extends HandlerInterface {
+    /** Adds a processor in the stack. */
+    pushProcessor(processor: Processor): this;
+    /**
+     * Removes the processor on top of the stack and returns it.
+     *
+     * Upstream throws `\LogicException` when the stack is empty; every
+     * pop-style method in this port (`Logger.popHandler()`,
+     * `AbstractProcessingHandler.popProcessor()`) returns `undefined` instead,
+     * and this signature follows them rather than upstream.
+     */
+    popProcessor(): Processor | undefined;
+}

package/out/Monolog/Handler/ProcessableHandlerInterface.luau

@@ -0,0 +1,15 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * PHP: `Monolog\Handler\ProcessableHandlerInterface`.
+	 *
+	 * Upstream pairs this with `ProcessableHandlerTrait`, which carries the
+	 * `$processors` stack and the `processRecord()`/`resetProcessors()` helpers.
+	 * Luau has no traits, so every implementer in this port spells those members
+	 * out itself -- `AbstractProcessingHandler`, `GroupHandler` and
+	 * `FingersCrossedHandler` each carry their own copy, the same way
+	 * `AbstractProcessingHandler` already folded the trait in before this
+	 * interface existed.
+	 
+]]
+return nil

package/out/Monolog/Handler/RobloxConsoleHandler.d.ts

@@ -1,55 +1,28 @@
 import { AbstractProcessingHandler } from "./AbstractProcessingHandler";
 import { Level } from "../Level";
-import type { FormatterInterface } from "../Formatter/FormatterInterface";
 import type { LogRecord } from "../LogRecord";
 /**
- * PHP: `Monolog\Handler\PHPConsoleHandler`.
+ * Writes formatted records to the Roblox output console.
  *
- * Upstream streams debug/error/exception data to the (now abandoned) "PHP
- * Console" Chrome extension via `PhpConsole\Connector`. There is no such
- * target on Roblox, so this adapts the same handler shape -- the `options`
- * bag, the record-kind branching in `write()`, the default formatter -- to
- * the platform's own output console (`print`/`warn`) instead, superseding
- * what the old, not-a-real-upstream-class `ConsoleHandler` used to do.
- */
-/**
- * Reduced from upstream's `Options`: everything else there
- * (`classesPartialsTraceIgnore`, `useOwnErrorsHandler`/`useOwnExceptionsHandler`,
- * `sourcesBasePath`, `registerHelper`, `serverEncoding`, `headersLimit`,
- * `password`, `enableSslOnlyMode`, `ipMasks`, `enableEvalListener`, every
- * `dumper*` key, `detectDumpTraceAndSource`, `dataStorage`) is either specific
- * to the PHP Console wire protocol or paired with `ErrorHandler`/`SignalHandler`,
- * both out of scope for this port -- there is no connector object left to
- * configure with them.
+ * No upstream ancestor: this is an original class for this platform.
+ *
+ * By shape it is this platform's `Monolog\Handler\StreamHandler`: hand
+ * `record.formatted` to the sink and nothing more. Roblox's console is that
+ * sink, and none of `StreamHandler`'s own API survives the swap -- there is
+ * no stream to open, no url/resource to accept, no file permissions, no
+ * `close()`, no buffering to flush. What is left is the level/bubble pair
+ * every handler has, plus the one choice the console does offer: records
+ * below `Level.Warning` go out through `print` (`MessageOutput`), the rest
+ * through `warn` (`MessageWarning`), so Studio colors them accordingly and
+ * `LogService` reports the right `Enum.MessageType`. `error` is deliberately
+ * not used for higher levels -- on Luau it throws and unwinds the caller
+ * instead of merely writing a line.
+ *
+ * The formatter is respected, unlike the PHP Console port that preceded this
+ * one: it is what turns the record into the printed text. The default is
+ * `AbstractProcessingHandler`'s own `LineFormatter`.
  */
-export interface Options {
-    /** Whether this handler is active at all. */
-    enabled: boolean;
-    /** Context keys checked, in order, for a debug "tag" to prefix the message with. */
-    debugTagsKeysInContext: Array<string>;
-}
 export declare class RobloxConsoleHandler extends AbstractProcessingHandler {
-    private readonly options;
-    constructor(options?: Partial<Options>, level?: Level, bubble?: boolean);
-    /** PHP: `PHPConsoleHandler::getOptions()`. */
-    getOptions(): Options;
-    /** PHP: `PHPConsoleHandler::handle()`. */
-    handle(record: LogRecord): boolean;
-    /** PHP: `PHPConsoleHandler::write()`. */
+    constructor(level?: Level, bubble?: boolean);
     protected write(record: LogRecord): void;
-    /** PHP: `PHPConsoleHandler::handleDebugRecord()`. */
-    private writeDebugRecord;
-    /** PHP: `PHPConsoleHandler::handleExceptionRecord()`. */
-    private writeExceptionRecord;
-    /** PHP: `PHPConsoleHandler::handleErrorRecord()`. */
-    private writeErrorRecord;
-    /**
-     * PHP: `PHPConsoleHandler::getRecordTags()`. Upstream also checks
-     * `$filteredContext[0]`, PHP's implicit first-array-index -- Luau/TS have
-     * no positional index on a `RecordBag`, so only the named
-     * `debugTagsKeysInContext` keys are checked.
-     */
-    private getRecordTags;
-    /** PHP: `PHPConsoleHandler::getDefaultFormatter()`. */
-    protected getDefaultFormatter(): FormatterInterface;
 }

package/out/Monolog/Handler/RobloxConsoleHandler.luau

@@ -4,36 +4,29 @@ local AbstractProcessingHandler = TS.import(script, script.Parent, "AbstractProc
 local _Level = TS.import(script, script.Parent.Parent, "Level")
 local Level = _Level.Level
 local Levels = _Level.Levels
-local LineFormatter = TS.import(script, script.Parent.Parent, "Formatter", "LineFormatter").LineFormatter
-local Utils = TS.import(script, script.Parent.Parent, "Utils").Utils
 --[[
 	*
-	 * PHP: `Monolog\Handler\PHPConsoleHandler`.
+	 * Writes formatted records to the Roblox output console.
 	 *
-	 * Upstream streams debug/error/exception data to the (now abandoned) "PHP
-	 * Console" Chrome extension via `PhpConsole\Connector`. There is no such
-	 * target on Roblox, so this adapts the same handler shape -- the `options`
-	 * bag, the record-kind branching in `write()`, the default formatter -- to
-	 * the platform's own output console (`print`/`warn`) instead, superseding
-	 * what the old, not-a-real-upstream-class `ConsoleHandler` used to do.
-	 
-]]
---[[
-	*
-	 * Reduced from upstream's `Options`: everything else there
-	 * (`classesPartialsTraceIgnore`, `useOwnErrorsHandler`/`useOwnExceptionsHandler`,
-	 * `sourcesBasePath`, `registerHelper`, `serverEncoding`, `headersLimit`,
-	 * `password`, `enableSslOnlyMode`, `ipMasks`, `enableEvalListener`, every
-	 * `dumper*` key, `detectDumpTraceAndSource`, `dataStorage`) is either specific
-	 * to the PHP Console wire protocol or paired with `ErrorHandler`/`SignalHandler`,
-	 * both out of scope for this port -- there is no connector object left to
-	 * configure with them.
+	 * No upstream ancestor: this is an original class for this platform.
+	 *
+	 * By shape it is this platform's `Monolog\Handler\StreamHandler`: hand
+	 * `record.formatted` to the sink and nothing more. Roblox's console is that
+	 * sink, and none of `StreamHandler`'s own API survives the swap -- there is
+	 * no stream to open, no url/resource to accept, no file permissions, no
+	 * `close()`, no buffering to flush. What is left is the level/bubble pair
+	 * every handler has, plus the one choice the console does offer: records
+	 * below `Level.Warning` go out through `print` (`MessageOutput`), the rest
+	 * through `warn` (`MessageWarning`), so Studio colors them accordingly and
+	 * `LogService` reports the right `Enum.MessageType`. `error` is deliberately
+	 * not used for higher levels -- on Luau it throws and unwinds the caller
+	 * instead of merely writing a line.
+	 *
+	 * The formatter is respected, unlike the PHP Console port that preceded this
+	 * one: it is what turns the record into the printed text. The default is
+	 * `AbstractProcessingHandler`'s own `LineFormatter`.
 	 
 ]]
-local DEFAULT_OPTIONS = {
-	enabled = true,
-	debugTagsKeysInContext = { "tag" },
-}
 local RobloxConsoleHandler
 do
 	local super = AbstractProcessingHandler
@@ -48,10 +41,7 @@ do
 		local self = setmetatable({}, RobloxConsoleHandler)
 		return self:constructor(...) or self
 	end
-	function RobloxConsoleHandler:constructor(options, level, bubble)
-		if options == nil then
-			options = {}
-		end
+	function RobloxConsoleHandler:constructor(level, bubble)
 		if level == nil then
 			level = Level.Debug
 		end
@@ -59,81 +49,20 @@ do
 			bubble = true
 		end
 		super.constructor(self, level, bubble)
-		local _object = {}
-		local _left = "enabled"
-		local _condition = options.enabled
-		if _condition == nil then
-			_condition = DEFAULT_OPTIONS.enabled
-		end
-		_object[_left] = _condition
-		_object.debugTagsKeysInContext = options.debugTagsKeysInContext or DEFAULT_OPTIONS.debugTagsKeysInContext
-		self.options = _object
-	end
-	function RobloxConsoleHandler:getOptions()
-		return self.options
-	end
-	function RobloxConsoleHandler:handle(record)
-		if self.options.enabled then
-			return super.handle(self, record)
-		end
-		-- Upstream also requires `connector.isActiveClient()` here; there is no
-		-- connector to ask, so `enabled` is the only gate left.
-		return not self.bubble
 	end
 	function RobloxConsoleHandler:write(record)
-		if Levels:isLowerThan(record.level, Level.Notice) then
-			self:writeDebugRecord(record)
-		elseif record.context.exception ~= nil then
-			self:writeExceptionRecord(record)
-		else
-			self:writeErrorRecord(record)
-		end
-	end
-	function RobloxConsoleHandler:writeDebugRecord(record)
-		local _binding = self:getRecordTags(record)
-		local tags = _binding[1]
-		local filteredContext = _binding[2]
-		local message = record.message
-		if (next(filteredContext)) ~= nil then
-			message = `{message} {Utils:jsonEncode(filteredContext)}`
+		-- `handle()` always fills `formatted` in before calling `write()`;
+		-- the fallback is for a direct call that did not go through it.
+		local _condition = record.formatted
+		if _condition == nil then
+			_condition = record.message
 		end
-		print(`[{tags}] {message}`)
-	end
-	function RobloxConsoleHandler:writeExceptionRecord(record)
-		warn(tostring(record.context.exception))
-	end
-	function RobloxConsoleHandler:writeErrorRecord(record)
-		local context = record.context
-		local message = if context.message ~= nil then tostring(context.message) else record.message
-		if context.file == nil and context.line == nil then
-			warn(message)
+		local message = _condition
+		if Levels:isLowerThan(record.level, Level.Warning) then
+			print(message)
 			return nil
 		end
-		local file = if context.file ~= nil then tostring(context.file) else "?"
-		local line = if context.line ~= nil then tostring(context.line) else "?"
-		warn(`{message} ({file}:{line})`)
-	end
-	function RobloxConsoleHandler:getRecordTags(record)
-		local filteredContext = {}
-		for key, value in pairs(record.context) do
-			filteredContext[key] = value
-		end
-		local tag
-		for _, key in self.options.debugTagsKeysInContext do
-			if filteredContext[key] ~= nil then
-				tag = tostring(filteredContext[key])
-				filteredContext[key] = nil
-				break
-			end
-		end
-		local _condition = tag
-		if _condition == nil then
-			_condition = Levels:toPsrLogLevel(record.level)
-		end
-		return { _condition, filteredContext }
-	end
-	function RobloxConsoleHandler:getDefaultFormatter()
-		return LineFormatter.new("%message%")
+		warn(message)
 	end
 end
 return {

package/out/Monolog/Handler/WhatFailureGroupHandler.d.ts

@@ -0,0 +1,26 @@
+import { GroupHandler } from "./GroupHandler";
+import type { LogRecord } from "../LogRecord";
+/**
+ * PHP: `Monolog\Handler\WhatFailureGroupHandler`.
+ *
+ * Forwards records to multiple handlers, suppressing failures of each handler
+ * and continuing through to give every handler a chance to succeed.
+ *
+ * Upstream wraps each call in `try { ... } catch (Throwable) {}`. Luau's
+ * error mechanism is `error()`/`pcall()`, not exceptions, so each call goes
+ * through `pcall()` and its failure result is discarded -- same "what
+ * failure?" semantics, same swallow-everything breadth.
+ */
+export declare class WhatFailureGroupHandler extends GroupHandler {
+    /** Handles a record, letting every grouped handler fail independently. */
+    handle(record: LogRecord): boolean;
+    /** Handles a set of records at once, ignoring any handler that fails. */
+    handleBatch(records: Array<LogRecord>): void;
+    /**
+     * Closes every grouped handler, ignoring any that fails.
+     *
+     * Upstream deliberately does not call `parent::close()` here (unlike
+     * `GroupHandler::close()`), so neither does this.
+     */
+    close(): void;
+}

package/out/Monolog/Handler/WhatFailureGroupHandler.luau

@@ -0,0 +1,85 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local GroupHandler = TS.import(script, script.Parent, "GroupHandler").GroupHandler
+--[[
+	*
+	 * PHP: `Monolog\Handler\WhatFailureGroupHandler`.
+	 *
+	 * Forwards records to multiple handlers, suppressing failures of each handler
+	 * and continuing through to give every handler a chance to succeed.
+	 *
+	 * Upstream wraps each call in `try { ... } catch (Throwable) {}`. Luau's
+	 * error mechanism is `error()`/`pcall()`, not exceptions, so each call goes
+	 * through `pcall()` and its failure result is discarded -- same "what
+	 * failure?" semantics, same swallow-everything breadth.
+	 
+]]
+local WhatFailureGroupHandler
+do
+	local super = GroupHandler
+	WhatFailureGroupHandler = setmetatable({}, {
+		__tostring = function()
+			return "WhatFailureGroupHandler"
+		end,
+		__index = super,
+	})
+	WhatFailureGroupHandler.__index = WhatFailureGroupHandler
+	function WhatFailureGroupHandler.new(...)
+		local self = setmetatable({}, WhatFailureGroupHandler)
+		return self:constructor(...) or self
+	end
+	function WhatFailureGroupHandler:constructor(...)
+		super.constructor(self, ...)
+	end
+	function WhatFailureGroupHandler:handle(record)
+		local processed = record
+		if not (#self.processors == 0) then
+			processed = self:processRecord(processed)
+		end
+		for _, handler in self.handlers do
+			pcall(function()
+				return handler:handle(processed:clone())
+			end)
+		end
+		return self.bubble == false
+	end
+	function WhatFailureGroupHandler:handleBatch(records)
+		local batch = records
+		if not (#self.processors == 0) then
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#records)
+			local _callback = function(record)
+				return self:processRecord(record)
+			end
+			for _k, _v in records do
+				_newValue[_k] = _callback(_v, _k - 1, records)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			batch = _newValue
+		end
+		for _, handler in self.handlers do
+			pcall(function()
+				-- ▼ ReadonlyArray.map ▼
+				local _newValue = table.create(#batch)
+				local _callback = function(record)
+					return record:clone()
+				end
+				for _k, _v in batch do
+					_newValue[_k] = _callback(_v, _k - 1, batch)
+				end
+				-- ▲ ReadonlyArray.map ▲
+				return handler:handleBatch(_newValue)
+			end)
+		end
+	end
+	function WhatFailureGroupHandler:close()
+		for _, handler in self.handlers do
+			pcall(function()
+				return handler:close()
+			end)
+		end
+	end
+end
+return {
+	WhatFailureGroupHandler = WhatFailureGroupHandler,
+}