parse-stack-next 5.5.4 → 5.5.5

data/docs/yard-template/default/fulldoc/html/css/common.css

@@ -438,17 +438,38 @@ input[name=q]::placeholder {
   margin-top: 1.4em;
 }
 
-#listing ul.alpha li.letter h2 {
+/* YARD emits the section letters as bare `<li class="letter">A</li>`
+ * (no inner h2), so style the li itself. */
+#listing ul.alpha li.letter {
   color: var(--accent);
-  border-bottom: 2px solid var(--accent);
-  display: inline-block;
-  padding: 0 .8em .2em 0;
+  font-weight: 650;
 }
 
 #listing ul li a {
   border-bottom: 1px dotted var(--border);
 }
 
+/* The "(Parse::Constraint)" origin annotations; stock #666 is too dim
+ * against the dark surfaces. */
+#listing ul small {
+  color: var(--fg-muted);
+}
+
+/* Stock style.css stripes index rows with hardcoded light grays
+ * (li.r1 #f0f0f0 / li.r2 #fafafa) that glow white in dark mode. */
+li.r1 { background: var(--bg-soft); }
+li.r2 { background: var(--bg); }
+
+/* File Listing pills at the top of _index.html. */
+.index_inline_list li,
+.index_inline_list li.r1,
+.index_inline_list li.r2 {
+  background: var(--bg-soft);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  margin-right: 6px;
+}
+
 /* -------- inheritance / mixin lists -------- */
 
 dl.box {
@@ -892,9 +913,13 @@ h2.h2_sum,
 
 /* The collapse arrows in the class-tree iframe are a base64 PNG
  * sprite of dark glyphs on a transparent background — invisible
- * against our dark surface. CSS filter inverts them in place. */
-#full_list li a.toggle {
-  filter: invert(0.85) hue-rotate(180deg) brightness(1.6);
+ * against our dark surface. CSS filter inverts them in place.
+ * Dark mode only: in light mode the stock dark glyphs are correct,
+ * and inverting them would wash them out against the light rail. */
+@media (prefers-color-scheme: dark) {
+  #full_list li a.toggle {
+    filter: invert(0.85) hue-rotate(180deg) brightness(1.6);
+  }
 }
 
 /* ============================================================
@@ -928,11 +953,29 @@ h2.h2_sum,
   padding: 1px 6px !important;
 }
 
-/* But never on the code blocks themselves (the pre.code descendants). */
+/* But never on the code blocks themselves (the pre.code descendants).
+ * The scoped variants are required, not belt-and-braces: file pages
+ * (README + guides) compile fenced blocks to <pre><code class="ruby">,
+ * and with both rules !important the positive `#filecontents code`
+ * (0,1,0,1) would otherwise beat a bare `pre code` (0,0,0,2) — the
+ * inline-level <code> then draws its border on every wrapped line
+ * fragment, streaking the whole block. */
 pre code,
 pre tt,
 pre.code code,
-pre.code tt {
+pre.code tt,
+.docstring pre code,
+.docstring pre tt,
+.tags pre code,
+.tags pre tt,
+.summary pre code,
+.summary pre tt,
+#filecontents pre code,
+#filecontents pre tt,
+.discussion pre code,
+.discussion pre tt,
+.method_details pre code,
+.method_details pre tt {
   background: transparent !important;
   border: 0 !important;
   padding: 0 !important;

data/docs/yard-template/default/fulldoc/html/css/full_list.css

@@ -209,19 +209,43 @@ a:visited {
  * parse-stack-next overlay (sidebar / class-list iframe)
  * ============================================================ */
 
+/* Scheme-aware palette. Light is the default; the dark block below
+ * mirrors common.css's prefers-color-scheme handling. Keeping the
+ * overlay unconditional (as it originally was) made the rail
+ * unreadable in light mode: common.css paints #full_list with the
+ * light surface while these rules kept the near-white dark-mode
+ * text (its `#full_list li .item a` selector out-specifies
+ * common.css's `#full_list li a` regardless of load order). */
 :root {
-	--ps-bg:        #1E1F22;
-	--ps-bg-soft:   #2A2C30;
-	--ps-bg-hover:  #34373C;
-	--ps-fg:        #E6E8EB;
-	--ps-fg-muted:  #9CA3AF;
-	--ps-accent:    #E63946;
-	--ps-link:      #4FB8F4;
-	--ps-border:    #3A3D42;
+	--ps-bg:        #FFFFFF;
+	--ps-bg-soft:   #F8F9FA;
+	--ps-bg-hover:  #E8EAED;
+	--ps-fg:        #1F2328;
+	--ps-fg-muted:  #6B7280;
+	--ps-accent:    #B22234;
+	--ps-link:      #169CEE;
+	--ps-border:    #E5E7EB;
+	--ps-scroll-thumb: #C7CBD1;
+	--ps-header-shadow: 0 1px 3px rgba(0, 0, 0, .08);
 	--ps-font:      -apple-system, BlinkMacSystemFont, "Segoe UI", "Inter",
 	                Roboto, "Helvetica Neue", Arial, sans-serif;
 }
 
+@media (prefers-color-scheme: dark) {
+	:root {
+		--ps-bg:        #1E1F22;
+		--ps-bg-soft:   #2A2C30;
+		--ps-bg-hover:  #34373C;
+		--ps-fg:        #E6E8EB;
+		--ps-fg-muted:  #9CA3AF;
+		--ps-accent:    #E63946;
+		--ps-link:      #4FB8F4;
+		--ps-border:    #3A3D42;
+		--ps-scroll-thumb: #4a4d52;
+		--ps-header-shadow: 0 1px 3px rgba(0, 0, 0, .3);
+	}
+}
+
 body {
 	background: var(--ps-bg) !important;
 	color: var(--ps-fg);
@@ -238,7 +262,7 @@ h1 {
 .fixed_header {
 	background: var(--ps-bg-soft) !important;
 	border-bottom: 1px solid var(--ps-border);
-	box-shadow: 0 1px 3px rgba(0, 0, 0, .3);
+	box-shadow: var(--ps-header-shadow);
 }
 
 #search input,
@@ -299,7 +323,7 @@ h1 {
 
 ::-webkit-scrollbar          { width: 8px; height: 8px; }
 ::-webkit-scrollbar-track    { background: var(--ps-bg); }
-::-webkit-scrollbar-thumb    { background: #4a4d52; border-radius: 4px; }
+::-webkit-scrollbar-thumb    { background: var(--ps-scroll-thumb); border-radius: 4px; }
 ::-webkit-scrollbar-thumb:hover { background: var(--ps-link); }
 
 /* ============================================================
@@ -381,7 +405,10 @@ body > #content {
 }
 
 /* The collapse toggle PNG is a dark-on-transparent sprite; invert it
- * so the arrow shows on dark backgrounds. */
-#full_list li a.toggle {
-	filter: invert(0.85) hue-rotate(180deg) brightness(1.6);
+ * so the arrow shows on dark backgrounds. Dark mode only — in light
+ * mode the stock dark glyphs are already correct. */
+@media (prefers-color-scheme: dark) {
+	#full_list li a.toggle {
+		filter: invert(0.85) hue-rotate(180deg) brightness(1.6);
+	}
 }

data/lib/parse/agent/constraint_translator.rb

@@ -72,9 +72,9 @@ module Parse
       ].freeze
 
       # Operators whose value carries an inner sub-query of the shape
-      # +{className:, where:, key:}+. Each must be validated through
+      # `{className:, where:, key:}`. Each must be validated through
       # {Tools.assert_class_accessible!} so the LLM cannot reach into a
-      # hidden class via the sub-query, and the inner +where+ must be
+      # hidden class via the sub-query, and the inner `where` must be
       # recursively re-translated so blocked operators inside it are
       # also caught.
       CROSS_CLASS_OPERATORS = %w[
@@ -260,11 +260,11 @@ module Parse
       end
 
       # Translate the value of a cross-class operator
-      # (+$inQuery+/+$notInQuery+/+$select+/+$dontSelect+). The value
-      # carries an embedded +className+ that must be validated against
-      # the active accessibility policy, and an embedded +where+ that
+      # (`$inQuery`/`$notInQuery`/`$select`/`$dontSelect`). The value
+      # carries an embedded `className` that must be validated against
+      # the active accessibility policy, and an embedded `where` that
       # must be recursively translated so blocked operators (e.g.
-      # +$where+ nested inside) cannot smuggle through.
+      # `$where` nested inside) cannot smuggle through.
       def translate_cross_class_value(op, val, depth:, agent: nil)
         return val unless val.is_a?(Hash)
         val = val.transform_keys(&:to_s)
@@ -321,20 +321,20 @@ module Parse
         translate_value(val, depth: depth, agent: agent)
       end
 
-      # Validate the owning-object class named by a +$relatedTo+ constraint.
+      # Validate the owning-object class named by a `$relatedTo` constraint.
       #
-      # +$relatedTo+ has the shape +{ object: <Pointer>, key: <relation field> }+.
-      # Unlike +$inQuery+ / +$select+ it carries no +className+ / inner +where+,
+      # `$relatedTo` has the shape `{ object: <Pointer>, key: <relation field> }`.
+      # Unlike `$inQuery` / `$select` it carries no `className` / inner `where`,
       # so it is NOT a {CROSS_CLASS_OPERATORS} entry — but it DOES reach across
       # to a second class: the owning object whose relation is being read. Left
       # unvalidated, an agent narrowed to one class (or with a class globally
-      # +agent_hidden+) could still name a relation anchored on an off-allowlist
-      # class via the +object+ pointer. That is the SDK-surface analog of
-      # GHSA-wmwx-jr2p-4j4r, where Parse Server's own +$relatedTo+ bypassed the
+      # `agent_hidden`) could still name a relation anchored on an off-allowlist
+      # class via the `object` pointer. That is the SDK-surface analog of
+      # GHSA-wmwx-jr2p-4j4r, where Parse Server's own `$relatedTo` bypassed the
       # owning object's ACL. Run the owning class through the same accessibility
       # policy as every other cross-class hop, then translate the value normally.
       #
-      # Fails closed when the owning class cannot be resolved from +object+: an
+      # Fails closed when the owning class cannot be resolved from `object`: an
       # unresolvable pointer is exactly the shape that would otherwise slip the
       # check, so refuse the constraint rather than skip it.
       def translate_related_to_value(val, depth:, agent: nil)
@@ -351,10 +351,10 @@ module Parse
         translate_value(val, depth: depth, agent: agent)
       end
 
-      # Extract the Parse class name of a +$relatedTo+ constraint's owning
-      # object from its +object+ slot, which may be a Parse::Pointer, a Parse
-      # pointer/relation hash (+{__type:, className:, objectId:}+, string or
-      # symbol keys), or a storage-form string (+"ClassName$objectId"+).
+      # Extract the Parse class name of a `$relatedTo` constraint's owning
+      # object from its `object` slot, which may be a Parse::Pointer, a Parse
+      # pointer/relation hash (`{__type:, className:, objectId:}`, string or
+      # symbol keys), or a storage-form string (`"ClassName$objectId"`).
       # Returns nil when no class can be resolved so the caller can fail closed.
       def related_to_owning_class(val)
         return nil unless val.is_a?(Hash)
@@ -371,7 +371,7 @@ module Parse
       end
 
       # Hook into the agent-side accessibility check when the agent
-      # module is loaded; in pure-unit contexts where +Parse::Agent::Tools+
+      # module is loaded; in pure-unit contexts where `Parse::Agent::Tools`
       # has not been loaded, default to a no-op rather than raising —
       # the strict check is enforced wherever the agent dispatches.
       def assert_embedded_class_accessible!(op, class_name, agent: nil)

data/lib/parse/agent/errors.rb

@@ -121,22 +121,22 @@ module Parse
       end
     end
 
-    # Raised inside the +call_method+ tool when the resolved
-    # +ClassName.method_name+ is excluded by the agent instance's
-    # +methods:+ filter. The execute() rescue maps this to a
-    # +:tool_filtered+ error_code so consumers can distinguish "the
+    # Raised inside the `call_method` tool when the resolved
+    # `ClassName.method_name` is excluded by the agent instance's
+    # `methods:` filter. The execute() rescue maps this to a
+    # `:tool_filtered` error_code so consumers can distinguish "the
     # filter excluded this method" from "this method isn't declared
     # agent-callable" (a Parse::Error) or "the tier doesn't allow it"
-    # (a +:permission_denied+).
+    # (a `:permission_denied`).
     class MethodFiltered < AgentError; end
 
     # Raised at semantic-search dispatch time when at least one class in
-    # the model registry declares +agent_tenant_scope+ but the class
+    # the model registry declares `agent_tenant_scope` but the class
     # being searched does not. In a tenant-aware deployment an
     # un-scoped searchable surface would let an agent retrieve across
     # tenant boundaries, so the gate is a hard refusal, not a warning.
     # Enforced at dispatch (when all classes are loaded) rather than at
-    # +agent_searchable+ declaration time so class-load order can't
+    # `agent_searchable` declaration time so class-load order can't
     # produce a false negative.
     class MissingTenantScope < AgentError; end
 
@@ -145,5 +145,27 @@ module Parse
     # `:refuse`. A SecurityError subclass so it routes through execute's
     # security rescue and is never swallowed.
     class PromptInjectionDetected < SecurityError; end
+
+    # Raised by Parse::Agent::Tools.invoke when a tool name is recognized
+    # (advertised in a permission tier / passes the gates) but has no
+    # handler in this SDK version. The built-in raw-CRUD write/admin tools
+    # (`create_object`, `update_object`, `delete_object`, `create_class`,
+    # `delete_class`) are declared in the write/admin tiers but ship
+    # without an implementation — invoking one previously raised a bare
+    # `NoMethodError` that collapsed to an opaque "internal error" on the
+    # wire. This turns that into a clear, typed refusal so the caller
+    # learns the tool is not implemented rather than that the SDK broke.
+    class NotImplemented < AgentError
+      attr_reader :tool_name
+
+      def initialize(tool_name, message = nil)
+        @tool_name = tool_name.to_s
+        super(message || "Tool '#{@tool_name}' is recognized but not implemented in this " \
+                         "SDK version. The built-in raw create/update/delete tools are not " \
+                         "available; expose the operation as an application method via " \
+                         "`agent_method` + `call_method`, or register a handler with " \
+                         "`Parse::Agent::Tools.register`.")
+      end
+    end
   end
 end

data/lib/parse/agent/metadata_dsl.rb

@@ -450,15 +450,15 @@ module Parse
         #   preview-only execution. When false (default), passing dry_run: true in
         #   arguments is refused at dispatch time with :invalid_argument.
         # @param permitted_keys [Array<Symbol,String>, nil] when provided,
-        #   +call_method+ refuses any +arguments+ key not in this list.
+        #   `call_method` refuses any `arguments` key not in this list.
         #   Without this, an LLM (or a prompt-injection payload) can
-        #   pass arbitrary keys through a method that splats with +**+,
-        #   reaching protected columns like +_hashed_password+ or +ACL+.
-        #   Highly recommended on any +agent_write+/+agent_admin+ method
+        #   pass arbitrary keys through a method that splats with `**`,
+        #   reaching protected columns like `_hashed_password` or `ACL`.
+        #   Highly recommended on any `agent_write`/`agent_admin` method
         #   that takes a kwargs splat.
         # @param parameters [Hash, nil] when provided, a JSON Schema (as a
-        #   Ruby Hash) describing the +arguments+ object. Surfaced in
-        #   +tools/list+ so the LLM submits properly-shaped inputs and
+        #   Ruby Hash) describing the `arguments` object. Surfaced in
+        #   `tools/list` so the LLM submits properly-shaped inputs and
         #   stricter MCP clients can validate before dispatch.
         # @return [Hash] the method metadata
         def agent_method(method_name, description = nil, permission: :readonly,