Shouldn't it be more something like the following?

[Scriban.Runtime.ScriptObjectExtensions]::Import($scriptObject.properties, $a) # this is how you call extension methods in PS

Not sure to follow why you would want to import all the metadatas of PSCustomObject, as [Scriban.Runtime.ScriptObjectExtensions]::Import is not aware about the particular structure of this PS objects, you need to give it some help, no?

@xoofx I was going off this example in the docs:

var scriptObject1 = new ScriptObject();
scriptObject1.Import(new MyObject());

var context = new TemplateContext();
context.PushGlobal(scriptObject1);

var template = Template.Parse("This is Hello: `{{hello}}`");
var result = template.Render(context);

// Prints This is MyFunctions.Hello: `hello from method!`
Console.WriteLine(result);

Where the ScriptObject static extension method Import is used to import properties for a .NET object (MyObject).

In PS,

[Scriban.Runtime.ScriptObjectExtensions]::Import($scriptObject, $a)

is the equivalent of doing

scriptObject.Import(a)

in C#.

Sorry, mixed the target object and the parameter:

[Scriban.Runtime.ScriptObjectExtensions]::Import($scriptObject, $a.properties)

The problem is that it looks like you are importing the wrong thing. The $a object is of type PSCustomObject, which seems to have e.g a properties which actually contain the properties. I would believe that's what you should import. Not the whole PSCustomObject that PowerShell specific.

To access PSCustomObject properties, you have to use $a.PSObject.Properties, which is of type PSMemberInfoIntegratingCollection, which seems to throws ScriptObject completely off, since both $scriptObject.properties and $context.CurrentGlobal are null.

The confusing thing is that when I use [Scriban.Runtime.ScriptObjectExtensions]::Import($scriptObject, $a), both $scriptObject.properties and $context.CurrentGlobal look as expected: the foo property is there, as well as its value, but the template is not rendered as expected.

Maybe the renderer fails to fetch the value correctly because foo is a NoteProperty? Can I write a template to print out all known variable names and values?

NB: This is not a huge issue, since I have a function to perform a simple conversion from a PSCustomObject to a hashtable and ConvertFrom-Json function in PS 6+ has the -AsHashtable parameter for parsing json.

The confusing thing is that when I use [Scriban.Runtime.ScriptObjectExtensions]::Import($scriptObject, $a), both $scriptObject.properties and $context.CurrentGlobal look as expected: the foo property is there, as well as its value, but the template is not rendered as expected.

They are not. Only properties should be imported.

Because otherwise you have to modify your script to go through properties:

$template = [Scriban.Template]::Parse('hello {{properties.foo}}')

That's why I'm suggesting to pass $a.properties because $context.CurrentGlobal looks wrong.

It should be instead something like:

$context.CurrentGlobal

Key                   Value
---                   -----
foo                   bar

Ok, I think I've got it.

I've tested it with a regular C# class and it worked as expected.

The problem is that PSCustomObject properties are not of MemberType Property, but NoteProperty, so using Import imports actual PSObject properties (base_object, properties, etc.)

Without Scriban treating NoteProperty members as regular properties, the correct approach is:

$a = [PSCustomObject]@{ foo = "bar" }
$scriptObject = [Scriban.Runtime.ScriptObject]::new()
$a.PSObject.Properties | ForEach-Object {
    $scriptObject.Add($_.Name, $_.Value)
}
$context = [Scriban.TemplateContext]::new()
$context.PushGlobal($scriptObject)
$template = [Scriban.Template]::Parse('hello {{foo}}')
$template.Render($context)

This is a naive implementation, since it doesn't handle nested PSCustomObject properties.