bindings/go/runtime/registry_test.go (1)

343-349: Strengthen the "two aliases" assertion to compare against def.

The current assertion only verifies that both aliases resolve to the same value as each other. A buggy implementation that mapped both aliases to the same incorrect Type would still pass this test. Asserting that each resolves to def directly catches that case and also makes the intent of the test more explicit.

🧪 Proposed test strengthening

 	t.Run("two aliases of the same type resolve to the same default", func(t *testing.T) {
 		alias2 := NewVersionedType("HelmHTTPCredentials", "v1alpha1")
 		scheme2 := NewScheme()
 		scheme2.MustRegisterWithAlias(&TestType{}, def, alias, alias2)
 
-		assert.Equal(t, scheme2.ResolveCanonicalType(alias), scheme2.ResolveCanonicalType(alias2))
+		assert.Equal(t, def, scheme2.ResolveCanonicalType(alias))
+		assert.Equal(t, def, scheme2.ResolveCanonicalType(alias2))
 	})

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@bindings/go/runtime/registry_test.go` around lines 343 - 349, Update the test
so it asserts that both aliases resolve to the expected canonical type `def`,
not just to each other: after registering with
`scheme2.MustRegisterWithAlias(&TestType{}, def, alias, alias2)` replace the
current equality check between `scheme2.ResolveCanonicalType(alias)` and
`scheme2.ResolveCanonicalType(alias2)` with assertions that
`scheme2.ResolveCanonicalType(alias)` equals `def` and
`scheme2.ResolveCanonicalType(alias2)` equals `def` (use the same `alias`,
`alias2`, `def`, `scheme2`, `ResolveCanonicalType` identifiers).

bindings/go/runtime/registry.go (1)

262-324: Optional: dedupe the defaults-then-aliases lookup across IsRegistered, NewObject, and ResolveCanonicalType.

The same two-step lookup pattern (defaults.GetLeft → aliases[typ]) is now repeated in IsRegistered (Lines 266-274), NewObject (Lines 306-317), and ResolveCanonicalType. Now that ResolveCanonicalType exists, you can express the others in terms of it (or an unexported helper that holds the lock once) to keep the resolution logic in one place. Purely a maintainability suggestion — feel free to defer.

♻️ Sketch (illustrative)

 func (r *Scheme) IsRegistered(typ Type) bool {
-	r.mu.RLock()
-	defer r.mu.RUnlock()
-
-	_, exists := r.defaults.GetLeft(typ)
-	if exists {
-		return true
-	}
-
-	// check if the type is an alias
-	_, exists = r.aliases[typ]
-
-	return exists
+	_, ok := r.ResolveCanonicalType(typ)
+	return ok
 }

NewObject could similarly resolve the canonical type first and then look up the prototype by it, collapsing the two branches into one.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@bindings/go/runtime/registry.go` around lines 262 - 324, Introduce a single
canonical-resolution helper and reuse it instead of duplicating the two-step
lookup: create an unexported method (e.g., resolveCanonicalLocked or
resolveCanonicalNoLock) that assumes r.mu is already locked and returns
(canonical Type, ok bool), or keep ResolveCanonicalType and add a small locked
wrapper that calls it; then change IsRegistered to call that resolver and return
ok, and change NewObject to first resolve the canonical type and then look up
the prototype via r.defaults.GetLeft(canonical) and instantiate it (preserving
instance.SetType(typ) and the r.allowUnknown behavior); ensure locking is
correct (hold RLock once around the resolve + defaults lookup) and preserve
existing panic/error semantics in MustRegisterWithAlias and NewObject.

bindings/go/runtime/registry_test.go (1)

380-385: Test case duplicates the unversioned-alias case rather than verifying cross-family isolation.

"alias of one type does not resolve to another type" uses the same input (helmAlias) and expected (helmDefault) as the earlier "unversioned alias resolves to default" case (lines 344-349), so it asserts the same behavior twice and does not actually exercise cross-family isolation as the name suggests. To make this case meaningful, assert that an alias from one family resolves to its own default and is not equal to the other family's default — e.g. resolve ociAlias and explicitly assert it differs from helmDefault (and vice versa).

♻️ Suggested change to make the case meaningful

 		{
-			name:       "alias of one type does not resolve to another type",
-			input:      helmAlias,
-			expected:   helmDefault,
-			expectedOk: true,
+			name:       "alias of one family does not resolve to another family's default",
+			input:      ociAlias,
+			expected:   ociDefault, // must be ociDefault, not helmDefault
+			expectedOk: true,
 		},

If you want an explicit negative assertion, you can add a small follow-up check after the table loop, e.g.:

resolved, _ := scheme.ResolveCanonicalType(ociAlias)
assert.NotEqual(t, helmDefault, resolved)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@bindings/go/runtime/registry_test.go` around lines 380 - 385, The test case
named "alias of one type does not resolve to another type" currently duplicates
the unversioned-alias case by using helmAlias and helmDefault; change it to
exercise cross-family isolation by using the other family's alias (e.g.,
ociAlias) as input and asserting its expected resolution is its own default
(e.g., ociDefault) and that it does not equal helmDefault, or vice versa. Locate
the table entry with name "alias of one type does not resolve to another type"
and update its input/expected to use ociAlias/ociDefault (or add a separate
negative assertion after the table loop calling
scheme.ResolveCanonicalType(ociAlias) and assert.NotEqual(t, helmDefault,
resolved)) so the test verifies aliases don't cross-resolve between families.